9,121 karma · joined May 16, 2012
Hi, I'm Vinh (@vinhnx on internet). iOS & Applied AI Engineer. I love to learn, build, and share.
Currently I'm building VT Code. VT Code is an open-source Rust terminal coding agent. https://github.com/vinhnx/VTCode
If you like my sharing. You can buymeacoffee via https://buymeacoffee.com/vinhnx
Thank you for your support!
Twitter: https://x.com/vinhnx GitHub: https://github.com/vinhnx HuggingFace: https://huggingface.co/vinhnx90 Personal site: https://vinhnx.github.io CV: https://vinhnx.github.io/cv YouTube: https://www.youtube.com/vinhnx90 Buy me a coffee: https://buymeacoffee.com/vinhnx
Learn by doing.
Video Special | Anthropic's Claude Opus 5 + https://www.youtube.com/watch?v=8Vdofv2vQ_M + https://www.youtube.com/watch?v=q-jHHx3J8m8
Here is my personal website https://vinhnx.github.io/
https://github.com/vinhnx/VTCode > It's an open-source coding agent with LLM-native code understanding and robust shell safety. Supports multiple LLM providers with automatic failover and efficient context management.
Recently it just got the 500th tagged release. The project has been started since August 2025, and the coding agent VT Code itself I believe to be stable and ready to use. Thankfully, I got help from the community; recently, we pushed quite a lot of releases, enhancements, and bug fixes.
VT Code: https://github.com/vinhnx/VTCode > An open-source coding agent with LLM-native code understanding and robust shell safety. Supports multiple LLM providers with automatic failover and efficient context management. => Recently it just got the 500th tagged release. The project has been started since August 2025, and the coding agent VT Code itself I believe to be stable and ready to use. Thankfully, I got help from the community; recently, we pushed quite a lot of releases, enhancements, and bug fixes.
VT Chat: https://github.com/vinhnx/vtchat > A modern, privacy-first AI chat application with security.
VT.ai: https://github.com/vinhnx/vt.ai > Multimodal AI chat app with dynamic conversation routing.
[0] https://github.com/vinhnx/VTCode/blob/main/README.md#Provide...
Notes: VT Code also supports custom OpenAI-compatible providers through the custom providers' configuration, allowing you to connect to any local LLM server that exposes an OpenAI-compatible API: https://github.com/vinhnx/VTCode/blob/a154162f/docs/config/C...
This is just my naive implementation, so as “llm-native code understanding,” VT Code will use LLMs to perform deep code understanding across multiple programming languages as a fallback if my enhance `ast-grep` + ripgrep + tree-sitter implementation is failed, but this relies on the model's intelligent. If you follow end-of last year post-training breakthrough (GPT-5.1 and Opus 4.5 era, November 2025), I read somewhere from Anthropic and OpenAI researchers that now the models are smart enough to understanding code with more context. They even have their own internal monologue so they can reason about code grammars and code context by itself. https://github.com/vinhnx/VTCode/blob/a154162f/docs/README.m...
Note: I don't have enough understanding describing this cleanly as I learn by doing mostly. However, initially when I designed and built VT Code, I had a vision of using and for AST-enhanced grep code for replacement of std grep. I also use my grep tool, called grep. `perg`). I also wanted to parse source code into concrete syntax trees usable in compilers, interpreters, text editors, and static analyzers. Also, I thought of using LSP but still exp. All this might be overhead for a small open source coding harness, but I love to build, so I thought to myself, why not, just build and learn.
I will answer your questions
> does ast-grep run first as a structural filter, with ripgrep for content matching, or are they used independently depending on the query type?
ast-grep and ripgrep are used independently depending on the query type, not in a sequential filtering relationship. In VT Code's, the `unified_search` tool provides two distinct search actions/args: `grep` and `structural`. Where, `grep` action uses ripgrep for broad text matching and quick file-content sweeps, which calls system `rg` binary or falls back to default grep (I also use my own perg, which is my cli for grep). The `structural` action uses ast-grep (https://ast-grep.github.io/) for syntax-aware search, read-only project scans, and rule tests, it directly executes ast-grep binary without any ripgrep preprocessing.
The routing is based on your search needs, design based on semantic:
- Plain text search -> `grep` action (ripgrep)
- Syntax-aware search -> `structural` action (ast-grep)
I design VT Code's system prompt to explicitly states to prefer `grep` (rg) for broad text search and prefer `structural` (ast-grep) for syntax-sensitive search.
> How are you handling the schema translation?
VT Code handles schema translation through a unified abstraction layer with provider-specific translation methods, avoiding provider-specific code paths in the main application logic. (https://github.com/vinhnx/vtcode/blob/main/vtcode-core/src/l...) The system uses a unified `LLMProvider` trait with shared request/response types, then handles provider-specific translations at the boundary layer.
Different providers have varying role support, handled through the `MessageRole` enum with provider-specific string conversion methods:
- OpenAI: Supports `system`, `user`, `assistant`, `tool` roles directly. Based on OpenAI Completion/Response API roles definition.
- Anthropic: Converts tool responses to `user` messages, handles system messages separately.
- Gemini: Maps `assistant` to `model`, handles system messages as `systemInstruction`.
Each provider implements the `LLMProvider` trait and handles its own schema conversion internally. For example, the Anthropic provider converts requests in `convert_to_anthropic_format()`.
> ACP support is interesting. I haven't seen many agents implement it yet, mostly MCP. Is your read that ACP is going to gain adoption, or is including both more about hedging?
I support and adopt ACP since it was first announced and introduced from Zed. And the currently VT Code run with almost all ACP-compatible clients (Zed, Minamo Notebook, Jetbrain, Toad...). See: https://github.com/vinhnx/VTCode/blob/main/docs/guides/zed-a.... I'm not sure about ACP adoption metric but ACP integration helps VT Code run on more surfaces (eg: environments).
> The local inference angle (LM Studio, Ollama) matters for use cases where source code can't leave the network. Have you benchmarked which open models hold up reasonably for tool-calling-heavy workflows? In my experience most local models below 70B struggle with multi-turn tool use even when their raw code generation is decent.
Currently, local inference support via LM Studio and Ollama is still early and experiment in VT Code and I haven't run it much and yet to have benchmarks with open models since I don't have enough VRAM. But it definitely in my checklist and could get helps from the comminity if anyone interest.
Thank you!