DEV Community: SN

TextRecast v0.2.0: User-Controlled Local AI Model Selection

SN — Sat, 01 Aug 2026 18:11:06 +0000

I’ve released TextRecast v0.2.0, a major update to my local-first Windows writing assistant.

TextRecast lets you select text in another Windows application and improve it, shorten it, expand it, summarize it, or change its tone using a small language model running locally on your computer.

There is no account, API key, Ollama installation, Python environment, or cloud text-processing service involved.

What changed in v0.2.0?

The main addition is explicit, user-controlled model selection.

Before TextRecast makes any model-download request, it now displays the available models along with:

Their intended role
Download size
Hardware compatibility
English-language status
Known limitations
Whether the model is experimental

TextRecast downloads only the exact model the user confirms.

Available models

Role	Model	Download	Status
Fast/default	Qwen 2.5 1.5B Q4_K_M	1.04 GiB	Established default
Balanced	Qwen 3.5 2B Q5_K_M	1.34 GiB	Experimental
Best quality	Qwen 3.5 4B Q5_K_M	2.93 GiB	Experimental
Alternative	Granite 4.1 3B Q5_K_M	2.27 GiB	Experimental

The smaller Qwen 2.5 model remains the fast default. The additional models are clearly marked as experimental because local language models can still alter facts, roles, conditions, or deadline wording.

All current profiles are intended for English rewriting.

Model-specific behavior

Different model families do not always respond well to the same prompt or sampling configuration.

For this release, I added separate adapters for:

Qwen 2.5
Qwen 3.5
Granite 4.1

Each adapter can define its own prompt format, chat template, stop sequences, and sampling profile while sharing the same installation and inference infrastructure.

This keeps the application architecture extensible without requiring a separate model server.

Safer model downloads

The download process remains user-controlled and verifiable:

TextRecast shows the available choices.
The user selects a model.
The exact model and size are shown for confirmation.
Only the confirmed model is downloaded.
The final file must match its expected size and SHA-256 checksum.
Interrupted downloads can resume instead of restarting.

A valid installed model is reused on later launches.

Public release archives remain model-free, so users do not download several gigabytes of models they may never use.

Hardware-aware selection

TextRecast inspects available memory, CPU capabilities, and storage before recommending a model.

The recommendation is guidance rather than a hidden automatic decision. The user still sees the available choices and controls which compatible model is installed.

Only one model is loaded at a time.

Local Windows integration

TextRecast uses Windows UI Automation, clipboard fallback, and input APIs to work with selected text in other applications.

Before replacement, it verifies the source window, process, capture age, and selected content. The selected and generated text are not intentionally written to application logs or history.

Model inference runs locally on the CPU through LLamaSharp.

Testing and packaging

For v0.2.0, I expanded the English qualification corpus and added model-specific benchmark tooling covering:

Output quality
Semantic preservation
Operation intent
Latency
Time to first token
Generation throughput
Peak memory usage

The repository currently passes all 126 automated tests.

The Windows x64 build is self-contained, so users do not need to install .NET 10 separately. The release also includes the applicable project, dependency, icon, .NET runtime, and WPF legal notices.

The Microsoft Visual C++ x64 Redistributable may still be required.

Try TextRecast

Repository:

https://github.com/snss10/TextRecast

v0.2.0 release:

https://github.com/snss10/TextRecast/releases/tag/v0.2.0

Download the complete TextRecast-v0.2.0-win-x64.zip, extract it, and run TextRecast.exe.

The application will ask you to choose and confirm one compatible model during setup.

TextRecast is open source under the Apache License 2.0.

Building a Hardware-Aware Multi-Model Foundation for TextRecast

SN — Thu, 30 Jul 2026 06:12:10 +0000

TextRecast is an open-source Windows writing assistant that rewrites selected text using a language model running entirely on the user’s computer.

There is no cloud API, separate Ollama installation, or external model service. Users select text in another application, choose a formatting operation, and TextRecast replaces the original selection with the generated result.

I recently completed the model foundation planned for TextRecast v0.2.0.

Why TextRecast needs multiple models

TextRecast currently uses Qwen 2.5 1.5B Instruct. It is small enough to run on many Windows computers while still producing useful results.

However, one model cannot provide the best experience for every computer.

A lightweight laptop may need a smaller and faster model, while a system with more memory can safely run a larger model with better output quality.

The goal for v0.2.0 is therefore to support:

Multiple local model families
Automatic selection based on hardware
Manual model selection
Resumable and verified model downloads
Model-specific prompts and generation settings
A repeatable qualification process

No additional model has been exposed to users yet. Models must first pass the TextRecast qualification process.

Vendor-neutral model adapters

The original implementation contained behavior designed specifically for Qwen and its ChatML format.

That behavior is now behind a model adapter contract. Each model family can define its own:

Prompt format
Sampling configuration
Stop sequences
Output cleanup
Expected output length

The existing Qwen behavior remains unchanged, but future models no longer need to copy or modify the main inference workflow.

This also makes it possible to support model families such as Phi, Granite, Ministral, or other suitable small language models without coupling the application to one vendor.

Local model qualification

I added a development-only benchmark runner that tests an existing local GGUF model. It never downloads a model and is excluded from the published application.

The corpus currently covers:

Improve writing
Shorten
Lengthen
Summarize
Every supported tone
Short, medium, and long text
Punctuation-heavy text
Adversarial instructions
English, Hindi, Spanish, French, German, and Japanese

The evaluator checks output presence, required information, length, repetition, protocol leakage, and language preservation.

What the first benchmark found

I ran the qualification suite against the current Qwen 2.5 1.5B model.

Results:

18 cases completed
9.0/10 overall score
No inference failures
No protocol leakage
No repetition failures
Strong English performance
Good Japanese result

The benchmark also exposed an important limitation: Hindi, Spanish, French, and German inputs were translated into English instead of preserving their original languages.

This is exactly why a project-specific qualification suite is valuable. A good general-purpose model is not automatically the best model for a specific application.

The score is a TextRecast-specific measurement, not a universal model benchmark.

Hardware-aware recommendations

TextRecast can now inspect:

Total and currently available memory
Logical processor count
Process architecture
AVX2 availability
Free model-storage space

The recommendation engine only accepts models with measured requirements. It rejects models that fail memory, storage, architecture, responsiveness, or minimum-quality requirements.

Memory recommendations include a 30% reserve over the measured peak requirement plus an additional 512 MiB safety allowance.

Among the safe profiles, TextRecast selects the highest-quality option.

Safe model settings

Automatic or Manual selection and the active model identifier can now be stored under the user’s local application-data directory.

Settings writes are atomic, and the application safely recovers from:

Missing settings
Corrupt JSON
Outdated schemas
Unknown model identifiers
Interrupted replacement attempts

Selected or generated user text is never stored in the settings file.

Validation

The completed foundation currently passes:

52 automated tests
Release formatting checks
A zero-warning Release build
Self-contained Windows publishing
Package validation with no bundled GGUF files
A real-model benchmark run
A foreground selection-to-replacement test

In the foreground test, TextRecast captured:

teh report dont include the final deadline

It generated and replaced the selection with:

The report does not include the final deadline.

The workflow completed in 4.79 seconds, and the previous clipboard contents were restored successfully.

What comes next

The next phase is to benchmark candidate models and select the best options for Fast, Balanced, and Best Quality profiles.

A candidate must reach at least 8.0/10 in the TextRecast qualification suite and satisfy language, memory, and responsiveness requirements before it can be shipped.

After qualification, I will add model installation, switching, deletion, automatic recommendations, and model-management UI.

TextRecast is open source, and you can follow its development here:

https://github.com/snss10/TextRecast

I Built TextRecast: A Local Windows Writing Assistant with .NET and an SLM

SN — Tue, 28 Jul 2026 18:52:12 +0000

Writing tools are useful, but I did not want to copy text into a separate website every time I needed to improve a sentence. I also wanted an option that did not send the selected text to a cloud inference API.

That idea became TextRecast, an open-source Windows utility that rewrites selected text inside the application where I am already working.

Select some text, click the floating TextRecast button, choose an operation, and apply the result back to the original selection. The language model runs locally on the CPU.

GitHub: github.com/snss10/TextRecast
Releases: github.com/snss10/TextRecast/releases
License: Apache License 2.0

What TextRecast can do

TextRecast currently supports:

Improving grammar, spelling, punctuation, wording, and clarity
Making selected text shorter or longer
Summarizing longer selections
Changing the tone to Professional, Casual, Friendly, Formal, or Direct
Replacing the original selection without requiring a manual copy-and-paste cycle

There is no account, API key, or text-processing cloud service involved. Normal formatting runs locally after the model has been installed.

Why local inference?

The main goal was not to build another chat interface. It was to create a focused editing tool that stays close to the text being edited.

Local inference provides a few useful properties:

Selected text is not submitted to a model API.
The tool continues working without an internet connection after model installation.
There is no per-request API cost.
The model lifecycle is controlled by the application.

TextRecast itself does not maintain a formatting history or write selected and generated text to log files.

There is still an important Windows-specific caveat: the fallback capture and replacement paths temporarily use the clipboard. Windows clipboard history, clipboard synchronization, or third-party clipboard managers may retain that content. Users working with sensitive text should disable those features.

The technology stack

TextRecast is built with:

WPF and .NET 10 for the Windows desktop application
LLamaSharp for local GGUF inference
Qwen2.5-1.5B-Instruct-GGUF as the initial small language model
Windows UI Automation for reading selected text when supported
Native Windows clipboard, window-focus, and input APIs for fallback capture and replacement
MSTest for workflow, prompt, chunking, and clipboard integration tests

The default model uses the Q4_K_M quantization. It is small enough to be practical on ordinary x64 Windows computers while still being useful for focused rewriting tasks.

Keeping the architecture replaceable

Although TextRecast currently ships with a Qwen model profile, the infrastructure is named around the more general concept of an SLM rather than one model family.

The solution is split into three main projects:

TextRecast.App ----------> TextRecast.Core
       |
       +-----------------> TextRecast.Infrastructure
                                   |
                                   +------> TextRecast.Core

TextRecast.App contains WPF presentation and application composition. TextRecast.Core contains formatting requests, workflows, contracts, results, and platform-independent models. TextRecast.Infrastructure contains LLamaSharp inference, model installation, and Windows integrations.

This separation means a future model can reuse installation, checksum verification, storage, chunking, inference lifecycle, and application workflow components. A model with a different chat format only needs an appropriate model profile and prompt builder.

First launch without bundling a 1.1 GB model

I did not want every source clone or application download to include a large model binary.

When TextRecast starts, it looks for:

A valid model packaged beside the application
A valid model previously installed for the current Windows user

If neither exists, a setup window downloads the model. The download can be cancelled or retried, and the UI reports both transfer and verification progress.

The installer does not trust a completed HTTP request by itself. It downloads to a uniquely named partial file, checks the expected file size and SHA-256 digest, and only then moves the file into its final location:

%LOCALAPPDATA%\TextRecast\Models

A failed or cancelled partial download is never treated as an installed model.

After installation, the first formatting request loads the model into memory. Later requests reuse the same model instance, so they usually begin faster.

Replacing text safely is harder than pasting

Generating text is only half of this application. Replacing the correct selection without damaging unrelated text or clipboard contents requires more care.

The replacement flow is approximately:

Capture selected text
        |
        v
Generate locally with the SLM
        |
        v
Revalidate window, process, age, and selected text
        |
        v
Snapshot clipboard formats
        |
        v
Paste the replacement
        |
        v
Restore and verify the clipboard snapshot

Before replacement, TextRecast verifies that the original window still exists, belongs to the same process, and contains the expected selection. Captured selections expire after a limited period instead of remaining valid indefinitely.

The clipboard snapshot owns deep copies of its captured formats rather than retaining a live Windows data object. After replacement, TextRecast rebuilds the clipboard and reads every captured format back to verify restoration. If replacement succeeds but restoration cannot be verified, the result window remains open and displays a warning instead of immediately disappearing.

The integration test for this path runs on a Windows STA thread. It captures Unicode text and a custom binary stream, temporarily replaces the clipboard, restores both formats, verifies their contents, and finally restores the clipboard that existed before the test.

Packaging the application

The Windows x64 release is published as a self-contained .NET application. Users do not need to install .NET 10 separately.

I chose a complete ZIP rather than distributing only one executable because the application also depends on native inference libraries and legal notice files. Every file in the archive needs to remain together.

The release package does not include the model, so the initial application download remains much smaller. The model is obtained through the verified first-launch flow described above.

Trying TextRecast

The packaged application requires:

Windows 10 or Windows 11 on x64 hardware
The current Microsoft Visual C++ x64 Redistributable
Approximately 1.5 GB of available disk space
An internet connection for the first model download

To try it:

Download the complete Windows x64 ZIP from the Releases page.
Extract the complete archive.
Run TextRecast.exe.
Allow the verified model installation to finish.
Select editable text in another application and click the floating TextRecast button.

Because early builds are not code-signed, Windows SmartScreen may display a warning. Always verify that the archive came from the official repository release.

Building from source

Development requires the .NET 10 SDK. From the repository root:

dotnet restore TextRecast.slnx
dotnet build TextRecast.slnx -c Release --no-restore
dotnet test TextRecast.slnx -c Release --no-build
dotnet run --project src/TextRecast.App/TextRecast.App.csproj

The CI workflow also verifies formatting, runs the complete test suite, builds in Release configuration, and publishes the self-contained Windows artifact.

Current limitations

TextRecast is an early release, and its boundaries are intentional:

It currently targets Windows x64 only.
Inference is CPU-only, so large selections take longer.
The first model download is approximately 1.1 GB.
The source application must support UI Automation selection or standard copy-and-paste shortcuts.
Windows may block simulated input when the source application runs as administrator and TextRecast does not.
Local inference improves privacy, but clipboard history and third-party clipboard managers remain outside the application's control.
The application is not yet code-signed.

These are useful constraints to state explicitly. "Local" should describe what the application actually does, not become a vague promise that ignores the operating system around it.

What comes next?

The SLM abstraction leaves room for additional local model profiles and prompt formats. I also want to continue improving performance, compatibility across Windows applications, accessibility, and the first-run experience based on real usage.

For now, the goal is deliberately focused: select text, transform it locally, verify that the original selection is still safe to replace, and return the result to the application where the work is happening.

If that workflow sounds useful, take a look at TextRecast on GitHub. Issues and technical feedback are welcome while the project is still taking shape.

[Boost]

SN — Sun, 21 Jun 2026 10:31:57 +0000

Jun 21

DBeast MCP

1 min read

DBeast MCP

SN — Sun, 21 Jun 2026 10:31:45 +0000

SQL access gives AI the data. DBeast gives it the investigation.

SN — Sun, 14 Jun 2026 09:10:37 +0000

snss10 / DBeast

Expert-level PostgreSQL database analysis MCP server for AI assistants.

A PostgreSQL MCP server that gives AI assistants expert DBA capabilities.

Quick Start · Demo · Tools · Safety · Configuration · Docs

DBeast connects AI assistants such as Claude, Cursor, Windsurf, and VS Code Copilot to PostgreSQL through the Model Context Protocol. Instead of exposing one broad execute_sql escape hatch, DBeast provides 21 focused tools for schema discovery, safe query execution, impact analysis, performance review, security checks, maintenance reporting, replication monitoring, and data quality inspection.

Demo

Watch Claude use DBeast MCP tools to audit a PostgreSQL database, identify security and maintenance risks, and preview cleanup impact without executing destructive SQL.

Watch the demo on YouTube

How It Works

AI assistant  --MCP stdio-->  DBeast server  --asyncpg-->  PostgreSQL
Claude/Cursor                  Python local                 Local, RDS,
Windsurf/VS Code               subprocess                   Supabase, Neon

DBeast runs as a local stdio MCP server. Your IDE or desktop assistant starts it as a subprocess and passes database credentials…

View on GitHub

Preventing context bloat and agent loops in database MCP servers

SN — Sun, 07 Jun 2026 08:29:52 +0000

I've been running Cursor and Claude Code with MCP for a while now, and one thing became obvious pretty quickly:

Giving an agent a generic execute_sql tool is usually a terrible idea.

The first problem is context explosion. If an agent needs to understand a database, it often starts by pulling huge schema dumps, table definitions, or query results directly into the conversation. Context gets consumed incredibly fast.

The second problem is what I call the agent loop trap. The model writes a query, gets an error, rewrites it, gets another error, and continues indefinitely. If you're using paid models, this can become surprisingly expensive.

To explore a different approach, I spent the last few weeks building DBeast, an open-source MCP server for PostgreSQL focused on discovery, diagnostics, and safety rather than unrestricted SQL execution.

Instead of exposing a single powerful database tool, DBeast exposes 21 specialized tools.

A few design decisions that ended up working well:

1. Schema mapping instead of schema dumping

Rather than feeding entire DDL definitions into context, the server reads information_schema and system catalogs to generate compact structural representations.

The goal is to help the model understand:

table relationships
foreign keys
cardinality
dependency graphs

without flooding the context window.

In many cases, a compact graph representation is dramatically more useful than thousands of lines of SQL.

2. Safety enforced at the tool layer

I didn't want agents performing unrestricted writes.

Read-oriented tools automatically enforce result limits, and mutation attempts are intercepted before execution.

For potentially destructive operations, the server can return an impact assessment instead:

estimated rows affected
dependency information
potential blast radius

This gives the model enough information to reason about consequences without actually making changes.

3. Breaking self-correction loops

One thing I noticed is that agents often treat database errors as invitations to keep retrying forever.

When PostgreSQL returns certain classes of errors, DBeast wraps them into structured responses that encourage the agent to stop, reassess, or ask for clarification instead of endlessly burning tokens.

4. Keeping everything local

The server runs locally using AsyncIO and standard MCP stdio transport.

Connection pools remain isolated, and no database metadata leaves the machine unless the host application chooses to send it to the model.

The project is MIT licensed and still early.

I'm particularly interested in how others are handling:

schema discovery
permission scoping
context management
preventing runaway agent/tool loops
safe database mutations

For those building MCP servers around data systems, what approaches have worked well for you?

GitHub: https://github.com/snss10/DBeast

I built DBeast: a PostgreSQL MCP server that gives AI assistants DBA-level tools

SN — Tue, 02 Jun 2026 21:25:33 +0000

AI assistants can write SQL.

But writing SQL is only a small part of working with a real database.

Most database work is investigation:

What tables exist?
How are they related?
Why is this query slow?
Which indexes are unhealthy?
Is autovacuum keeping up?
Are there risky permissions?
Which columns may contain sensitive data?
What would happen if we changed or deleted this data?

That is what I built DBeast for.

DBeast is a PostgreSQL MCP server that gives AI assistants structured DBA-style tools for understanding, analyzing, and troubleshooting PostgreSQL databases.

GitHub: https://github.com/snss10/DBeast

Why I built it

A lot of AI database integrations start with a simple tool:

execute_sql(query)

That is useful, but it is also incomplete.

A good database assistant should not just run SQL.

It should help you reason about the database.

It should inspect schemas, explain query plans, identify maintenance issues, detect security risks, analyze data quality, and help you understand the impact of changes before you make them.

That is the idea behind DBeast.

What DBeast does

DBeast exposes 21 MCP tools for PostgreSQL across areas like:

Schema discovery
ERD generation
Safe SELECT query execution
Query analysis
Query optimization hints
Write-impact previews
Database health checks
Maintenance analysis
Index and vacuum insights
Security audits
Sensitive data detection
Data quality reports
Duplicate detection
Replication monitoring
PostgreSQL configuration review
Audit logging

Instead of giving the assistant one giant database tool, DBeast gives it focused tools that map to real DBA workflows.

The bigger idea

I do not want AI assistants to be just SQL autocomplete.

I want them to become useful database copilots.

With DBeast, you can ask things like:

Show me how the sales schema is structured and generate an ERD.

Investigate why this dashboard query is slow and suggest indexes.

Review the public schema for maintenance issues, security risks, and data quality problems.

Compare table bloat, dead tuples, and index health across all schemas.

Find columns that may contain sensitive customer data.

Check replication lag and tell me if anything looks unhealthy.

That is much more useful than just:

Run this SQL.

Safety still matters

DBeast is designed to be safe by default.

SELECT queries can run with automatic row limits.

But write operations like:

INSERT
UPDATE
DELETE
DROP
TRUNCATE

are not executed directly.

They are analyzed as impact previews.

So instead of blindly running a risky query, your assistant can tell you:

what tables may be affected
how many rows may change
whether related objects are involved
what the risk level looks like
what you should review first

The human stays in control.

How it works

DBeast runs as a local MCP server.

AI assistant  ->  DBeast MCP server  ->  PostgreSQL

Your assistant talks to DBeast through the Model Context Protocol. DBeast talks to PostgreSQL using asyncpg.

It works with:

Local PostgreSQL
Docker PostgreSQL
AWS RDS / Aurora
Supabase
Neon
Railway
Render
Fly.io
SSH tunnels
AWS Secrets Manager

Quick start

git clone https://github.com/snss10/DBeast.git
cd DBeast
pip install -e .

Example MCP config:

{
  "mcpServers": {
    "dbeast": {
      "type": "stdio",
      "command": "python",
      "args": ["/absolute/path/to/DBeast/src/server.py"],
      "env": {
        "DATABASE_URL": "postgresql://user:password@localhost:5432/mydb"
      }
    }
  }
}

Then ask your assistant about your database.

Who this is for

DBeast may be useful if you:

use PostgreSQL
use Cursor, Claude Desktop, Windsurf, or another MCP client
want AI help understanding a database
want query and performance analysis
want safer database workflows
want a local tool instead of a hosted database agent

What I’m looking for

This is an early release, and I would love feedback from:

PostgreSQL users
DBAs
backend engineers
MCP builders
people experimenting with AI developer tools

I’m especially interested in:

what database workflows you would want next
whether setup is clear
what safety checks would make this more trustworthy
which MCP clients you want first-class examples for

GitHub: https://github.com/snss10/DBeast