We're excited to announce Nanocoder 1.22.0! It's packed with powerful new features that make working with your codebase more intuitive and productive than ever.

## What's New in This Release

### Interactive File Explorer with `/explorer`

Navigating complex codebases just got a lot easier. The new `/explorer` command brings an interactive file browser directly into your terminal with:

- **Tree view navigation** for intuitive directory exploration
- **File preview** with syntax highlighting to quickly understand code context
- **Multi-file selection** to work with multiple files at once
- **Search mode** for finding exactly what you need
- **VS Code integration** so selected files can be opened in your editor

Try it out by typing `/explorer` in any chat session - it's perfect for getting oriented in unfamiliar projects or surfacing the right files for your AI assistant to review.

### Task Management for Complex Workflows

We've finally bought a new task management system. The model can automatically create tasks or you can use the `/tasks` command to break down and track progress on multi-step work:

- **Create, list, update, and delete tasks** with dedicated tools
- **Persistent storage** in `.nanocoder/tasks.json` so tasks survive between sessions
- **Automatic cleanup** when you restart the CLI or run `/clear`
- Perfect for feature development, bug fixes, and refactoring projects

Now you can have clear, shared visibility into what needs to be done and what's already complete. It was a long time coming.

### Enhanced Provider Support

We've added several improvements for working with different AI providers:

**Native Gemini & Anthropic Support**: Configure the `sdkProvider` option to use Google's native Gemini integration as well as Anthropic's. This allows more flexibility for provider use.

**Custom Headers**: Need to authenticate through tunnels like Cloudflare? Provider configurations now support custom headers for advanced networking scenarios.

**Kimi Code Provider**: A new provider template has been added to the configuration wizard for easy setup.

### Settings Interface and New Themes

Customization is easier than ever. The `/settings` command opens an interactive menu to configure your UI theme and shape preferences without editing config files manually. We've also added beautiful new themes and updated styling for improved visual clarity and consistency.

### Improved UI

We've given the new version of Nanocoder a fresh look. Assistant/User messages now look cleaner than ever. We've also given token information per message to help you keep track of what context going in and coming out of the model over and above the `/usage` command.

## Under the Hood

This release includes important improvements to developer experience:

- **Git tool refactoring** for better consistency, error handling, and user feedback
- **Line truncation** in file operations to prevent excessive output on narrow terminals
- **Enhanced security** with multiple vulnerability fixes

## Bug Fixes

- Fixed `/usage` command crashes when context data is unavailable
- Improved string replace error handling for edge cases
- Security audit issues resolved

## Get Started

Update Nanocoder to version 1.22.0 today and experience the improvements - we hope you love it :)

```bash
npm install -g nanocoder
# or with your preferred package manager
```

Nano Project

Released

Nanocoder 1.22.0: New UI, Interactive File Explorer, Task Management, and More

The terminal-based AI coding assistant space is moving fast. Tools like Claude Code, Gemini CLI, and various open-source alternatives have made "agentic coding" - where an LLM autonomously reads, writes, and executes code - accessible to developers everywhere.

But as the ecosystem matures, a pattern has emerged that concerns us: many popular tools are built on foundations that prioritise rapid growth over long-term stability. Exploit-based provider access, venture-backed pivots, and pseudo-open-source governance create real risks for developers who build their workflows around these tools.

**Nanocoder is our answer.** It's a local-first, open-source coding assistant CLI designed to be boring in all the right ways: stable, private, and built on legitimate protocols that won't disappear overnight.

We're not claiming Nanocoder is the most feature-complete option today (although we're adding features fast!). We're building it to be the most *trustworthy* one.

---

## The Problem with "Move Fast and Break Things"

Let's talk about what happened with OpenCode.

OpenCode grew rapidly by enabling users to route their Claude Pro subscriptions through autonomous agent loops - usage patterns that would normally cost thousands in API fees. This worked through header spoofing that made requests appear to come from official clients.

On January 9, 2026, Anthropic implemented server-side checks that blocked this traffic. Accounts were reviewed. Workflows collapsed overnight.

You can debate whether Anthropic's response was heavy-handed. But the underlying point stands: **if your productivity depends on an exploit, you're one patch away from starting over.**

Shortly after the block, OpenCode pivoted to "OpenCode Black" - a $200/month premium tier. Users who'd chosen the tool for its open-source ethos found themselves facing a familiar choice: pay up or find something else.

This isn't a critique of OpenCode's team specifically. It's what happens when venture-backed projects need to show returns. The incentives push toward monetisation, and "free and open" becomes "free until we need revenue."

---

## What We're Doing Differently

Nanocoder is governed by the Nano Collective - a group of developers building open-source AI tools without venture funding. This isn't ideological purity for its own sake. It's a practical decision about incentives.

**MIT Licensed, genuinely.** Our code is yours to fork, modify, and build on. No contributor license agreements that let us relicense later. No "open core" where the useful bits are proprietary.

**Free, sustainably.** We don't have investors expecting a 10x return. Nanocoder is free and will stay that way. We fund development through donations and consulting work, not by eventually converting users into subscribers.

**Building toward independence.** Nanocoder works with cloud providers today, but our goal is to make them optional. We're actively developing architectures that help smaller, local models perform better at coding tasks. The endgame isn't "use Claude through a nicer interface" - it's a world where you can run a capable coding agent entirely on your own hardware, free from subscription fees, API limits, and policy changes you didn't agree to.

---

## Local-First by Design

If you're looking for a Claude Code alternative or terminal AI coding tool that respects your privacy, this matters: Nanocoder is designed to run locally.

Your code stays on your machine. Your prompts stay on your machine. If you're running a local model through Ollama or LM Studio, even the inference happens locally.

This isn't just about privacy (though that matters). It's about performance. A lightweight harness means more resources for your local LLM. We've built Nanocoder with the Ink framework specifically to keep CPU overhead minimal - your model gets the cycles it needs.

Compare this to reports of some terminal AI tools consuming 30-50% CPU while idle. When you're running a local model, that overhead translates directly into slower responses and degraded output quality.

---

## What Nanocoder Does Well Today

We're at 935 stars and 64 releases. Here's what's working:

**A beautiful, customisable CLI.** Themes, custom commands, flexible configuration - Nanocoder looks good in your terminal and adapts to how you work. We've built it with the Ink framework for a responsive, low-overhead experience.

**Universal provider support.** Any OpenAI-compatible API works out of the box. Ollama, LM Studio, llama.cpp, vLLM, LocalAI for local inference. OpenRouter, OpenAI, or any cloud provider with a compatible endpoint. Switch providers with `/provider`, and Nanocoder remembers your preferred model for each one.

**Three development modes.** Toggle between Normal (review each tool call), Auto-accept (faster workflows), and Plan mode (AI suggests but doesn't execute - useful for exploration). Switch with Shift+Tab.

**MCP integration.** Full support for the Model Context Protocol with stdio, HTTP, and WebSocket transports. Connect to filesystem servers, GitHub, Brave Search, or any MCP-compatible tool. The `/mcp` command shows connected servers and available tools.

**Built-in tools that matter.** File operations, bash command execution with `!command` syntax (output becomes context for the LLM), and `@file` fuzzy search to include file contents in messages. A `/usage` command shows context consumption visually.

**Custom commands as Markdown.** Define reusable prompts in `.nanocoder/commands/` with YAML frontmatter for parameters, descriptions, and aliases. Template variables with `{{parameter}}` syntax. Organise by namespace through directories. Ships with `/test`, `/review`, `/refactor:dry`, and `/refactor:solid` out of the box.

**Project-aware configuration.** `agents.config.json` can live at project level (for team sharing) or user level. Same for preferences - Nanocoder remembers your choices across sessions.

**VS Code extension.** Run with `--vscode` for live diff previews of file changes directly in your editor before approving.

**Cross-platform.** Works on Linux, macOS, and Windows. Install via npm, Homebrew, or Nix Flakes.

For full documentation: [github.com/Nano-Collective/nanocoder](https://github.com/Nano-Collective/nanocoder)

---

## What We're Working On

We're actively developing on two fronts.

First, we're closing gaps with established coding agents - the features developers expect as table stakes. Context management, tool reliability, edge case handling.

Second, we're exploring architectures designed specifically to help smaller models perform better at coding tasks. This matters if you care about local-first development. A 7B parameter model running on your laptop will never match a cloud-hosted frontier model in raw capability. But with the right scaffolding - better context management, smarter tool orchestration, more structured reasoning loops - you can close that gap significantly.

That's the work that excites us: not just wrapping API calls in a nice interface, but rethinking how the harness itself can augment model performance. We're experimenting with different approaches and will share what we learn.

---

## The Philosophy Behind the Tool

The agentic coding space will consolidate. Some tools will become the "walled gardens" backed by major players. Others will flame out when funding dries up or exploits get patched.

We're betting there's room for a third path: community-owned tools built on stable foundations, developed transparently, and designed to last.

Nanocoder isn't trying to be the flashiest option. We're trying to be the one that's still working reliably in two years, without having pivoted to a subscription model or gotten acquired.

If that resonates with you, we'd love your help - whether that's using Nanocoder, contributing code, or just telling us what's broken.

---

## Get Started

```bash
npm install -g @nanocollective/nanocoder
nanocoder
```

Or via Homebrew:

```bash
brew tap nano-collective/nanocoder https://github.com/Nano-Collective/nanocoder
brew install nanocoder
```

Check out the [GitHub repo](https://github.com/Nano-Collective/nanocoder), join the [Discord](https://discord.gg/ktPDV6rekE), or just start using it and tell us what's broken.

*Built by the community, for the community.*

Article

Why We're Building Nanocoder: A Local-First Coding Agent for the Long Haul

We're excited to announce Nanocoder 1.21.0, a release focused on making your local AI coding experience more powerful, flexible, and reliable. This version introduces hierarchical configuration management, intelligent tool support detection, and a collection of quality-of-life improvements that developers have been asking for.

## Hierarchical Configuration Loading

One of the most requested features is now here: **project-level configuration overrides**. Nanocoder 1.21.0 introduces hierarchical configuration loading for both provider configs and MCP servers. This means you can now:

- Set up global provider configurations in `~/.config/nanocoder/`
- Override them with project-specific settings in your local `.nanocoder/` directory
- Have Claude Code's object-style MCP configuration format automatically recognized and supported

This makes it incredibly easy to manage different configurations for different projects without manually switching settings between tasks.

## Automatic Tool Support Detection

Models vary widely in their capabilities - some don't support function calling at all. We've added **automatic tool support error detection with intelligent retry logic**. When Nanocoder detects that a model doesn't support tool calling, it automatically retries the request without tools, allowing the conversation to continue seamlessly. No more errors or failed requests for models with limited capabilities.

## Message Compression at Scale

Working with large conversations can be challenging. The new `/compact` command lets you compress your conversation context with the `--restore` flag to recover original messages if needed. Combined with auto-compact functionality and consistent token counting, managing lengthy sessions is now more straightforward.

## New Commands & Configuration Options

We've added several useful commands and options:

- **`/quit`** - A new alternative to exit Nanocoder (complementing the existing exit methods)
- **`/nanocoder-shape`** - Select your preferred branding font styles for custom commands
- **`--version` and `--help`** - Quick reference CLI options at your fingertips
- **`alwaysAllow` configuration option** - Mark trusted MCP server tools to skip confirmation prompts

## Under the Hood

Beyond these headline features, we've fixed critical issues:

- **Bash tool now properly cleans up processes** - Previously, background processes could persist after command completion
- **Improved bash security** - Resolved shell command security scanning alerts from environment values
- **Better error handling** - Enhanced tool error detection and retry mechanisms
- **Better UX** - Improved `/mcp` and `/help` command styling with better colors and formatting

## Try It Out

We love getting developer feedback so try it out today!

If you have feedback or encounter any issues, please reach out through our [GitHub issues page](https://github.com/Nano-Collective/nanocoder/issues) or join us on Discord.

Happy coding! 🙌


Nanocoder 1.21.0: Enhanced Configuration, Smarter Tool Handling, and Better Reliability

Happy New Year! 🥳

We're excited to kick off 2026 with Nanocoder 1.20.0, a release packed with powerful features, comprehensive testing, and significant quality improvements. Whether you're using Nanocoder for rapid development, code exploration, or complex multi-file refactoring, this release brings meaningful enhancements across every layer of the platform.

It was a labour of love over the holidays from our contributors!

Before we go into the update though, we all want to thank you for an incredible 2025 - Nanocoder was launched just 5-months ago and its quality, community and vision has only grown.

Heading into 2026 we've crossed 1K stars and get over 4,000 downloads a month. We have an incredible core team now and so many amazing contributors putting in work to make Nanocoder great.

Our mission has alway been to build community-led solutions that focus on privacy and local-first AI. We're only going to continue on that mission this year. Thanks to everyone!

## What's New in 1.20.0

### Visual Enhancements

We've introduced **Catpuccin themes** with full gradient color support, giving you four beautiful options: Latte, Frappe, Macchiato, and Mocha. Whether you prefer light or dark aesthetics, these carefully curated themes make extended coding sessions more personalised to you. Plus, we've added **stylized title boxes** with powerline-style shapes and real-time preview support in custom commands, giving your terminal output a polished, professional appearance. We believe your CLI experience should be yours and made to be beautiful.

### VS Code Plugin Improvements

Right-clicking code in VS Code? Now you can directly ask Nanocoder about it through the **context menu integration**. This tighter editor integration means fewer context switches and faster feedback loops during development.

### Expanded Language Support

Language Server Protocol (LSP) support has been significantly expanded with **automatic project detection** for Deno, GraphQL, Docker, and Markdown language servers. The setup wizard now features **auto-fetch models**, allowing providers to automatically discover available models during configuration. This means less manual setup and better out-of-the-box experiences.

### Git Workflow Tools

We've added comprehensive **git workflow integration**, including:
- Smart commit message generation
- PR template creation
- Branch naming suggestions
- Enhanced status reporting

These tools leverage AI to streamline your git workflows, reducing friction in your development process.

### Performance & Reliability

- **90%+ code coverage** across components, hooks, tools, and utilities with comprehensive unit and integration tests
- **File content caching** reduces tool confirmation delays and improves responsiveness
- **Real-time bash output progress** with live updates during command execution
- **Inline word-level highlighting** in string_replace diff display for clearer visualization of changes

### Security Improvements

- Path boundary validation prevents directory traversal attacks
- Granular debug logging with structured Pino logger for better error tracking
- Enhanced error handling with AI SDK error types
- Switched to crypto.randomUUID and crypto.randomBytes for secure ID generation

### Infrastructure

- **Devcontainer support** for streamlined development environments
- **Automated PR checks workflow** with format, type, lint, and test validation
- Improved tool caller prompts and descriptions for better model interaction
- Refactored core components for maintainability

## Under the Hood

This release includes significant architectural improvements: the App component has been refactored into focused modules (useAppState, useAppInitialization, useChatHandler, useToolHandler), file operations have been switched to async operations for better performance, and multiple files have been renamed to kebab-case for consistency.

Code exploration tools are now smarter with better prompts and a new `list_directories` tool. Ignored file patterns are now centralized for consistency, and tool formatters provide improved indentation for readability.

## Get Started Today

Nanocoder 1.20.0 is available now and ready for use. Whether you're upgrading for the new themes, git integration, or the comprehensive testing improvements, you'll notice immediate benefits in your workflow.

[Download the latest version](https://github.com/Nano-Collective/nanocoder) and explore what makes Nanocoder the developer's choice for AI-assisted coding.

Thank you to our incredible community of contributors who made this release possible. Your feedback, bug reports, and pull requests drive our continuous improvement. If you have thoughts or run into any issues, reach out via our [GitHub issues](https://github.com/Nano-Collective/nanocoder/issues) or join us on [Discord](https://discord.gg/nanocoder).

Nanocoder 1.20.0: Fresh Year, Fresh Features

Nanocoder 1.19.0 is here, and it's another big one! Packed with powerful new features designed to make your AI-powered coding workflow more flexible, reliable, and production-ready.

## What's New in 1.19.0

### Non-Interactive Mode for CI/CD Pipelines

We've included non-interactive mode. You can now run Nanocoder directly in CI/CD pipelines and automation scripts by passing commands via CLI arguments. Nanocoder executes your request and exits automatically. No interactive prompts, no waiting for user input.

This opens up exciting possibilities:
- Integrate Nanocoder into your GitHub Actions, GitLab CI, or Jenkins workflows
- Automate code reviews, refactoring, and documentation tasks
- Use Nanocoder as part of your build pipeline for intelligent code generation

```bash
# Example: Run Nanocoder non-interactively
nanocoder "Summarise what the README.md file says"
```

### Conversation Checkpointing System

We've implemented an interactive conversation checkpointing system that lets you save and restore your chat sessions across different workdays and projects. Never lose context again. Your conversations are now persistent, allowing you to:

- Save complex multi-step conversations for later reference
- Resume work exactly where you left off
- Maintain project-specific context across sessions
- Build knowledge bases from your interactions

### Enterprise-Grade Pino Logging

For teams running Nanocoder in production environments, we've integrated a comprehensive structured logging system powered by Pino. This new logging infrastructure provides:

- Structured logging for easier parsing and analysis
- Request tracking across tool executions
- Performance monitoring to identify bottlenecks
- Configurable log levels (debug, info, warn, error)
- Perfect for debugging issues in containerized environments

### Tooling Improvements

- **Faster Code Quality Tooling**: We've switched from Prettier and ESLint to Biome, delivering faster formatting and linting without sacrificing code quality standards.
- **New Provider Templates**: Added support for Poe.com and Mistral AI in the configuration wizard, expanding your LLM provider options.
- **Cleaner Dependencies**: Removed the `ink-titled-box` dependency and replaced it with a custom, lightweight implementation—reducing bloat and bugs while maintaining visual quality.

### Under the Hood

- Updated Ollama model contexts for improved compatibility
- Added `--force` flag to `/init` command for regenerating AGENTS.md without user prompts
- Fixed critical security vulnerabilities flagged by pnpm audits
- Fixed README table of contents anchors for proper GitHub fork navigation
- Refactored GitHub Actions workflows to reduce duplication and improve maintainability

## Get Started Today

Have questions or feedback? Drop us a line on [Discord](https://discord.gg/nanocoder) or open an issue on [GitHub](https://github.com/Nano-Collective/nanocoder). We'd love to hear how you're using Nanocoder!

Thank you for being part of the Nanocoder community. 🙌


Nanocoder 1.19.0: Non-Interactive Mode, Conversation Checkpointing, and Enterprise-Grade Logging

We're excited to announce Nanocoder 1.18.0, a release packed with improvements to how the AI agent handles tool calls, new debugging capabilities, and a completely revamped model discovery experience.

## AI SDK v6 Beta: Multi-Step Tool Calls Are Here

The headline feature of this release is the upgrade to AI SDK v6 beta. This brings significant improvements to model and tool calling performance, but more importantly, it introduces **multi-step tool calls support**.

What does this mean in practice? Previously, when Nanocoder needed to perform multiple operations, each tool call was handled sequentially with the model reasoning between each step. With multi-step tool calls, the agent can now chain operations more efficiently, leading to faster task completion and more coherent workflows.

This upgrade was contributed by @DenizOkcu, who also fixed locale-related test failures that were affecting some users.

## New `/debugging` Command

Sometimes you need to see exactly what's happening under the hood. The new `/debugging` command toggles detailed tool call information, showing you the raw data being passed between the model and tools. This is invaluable when:

- Troubleshooting unexpected behavior
- Understanding how the model is interpreting your requests
- Contributing to Nanocoder development

Thanks again to @DenizOkcu for this addition.

## From `/recommendations`, to `/model-database`

We've replaced the `/recommendations` command with a more powerful `/model-database` command. Instead of static recommendations, you now have access to a searchable database of models with up-to-date information about capabilities, context sizes, and more.

This change makes it significantly easier for us to maintain accurate model information and for you to find the right model for your use case.

## Cleaner Status Display

LSP and MCP server connection status is now displayed directly in the Status component. This provides much cleaner visibility into your connected services without cluttering the main UI with verbose connection messages. Thanks to @Avtrkrb for this improvement.

## GitHub Issue Templates

We've added structured issue templates for bug reports and feature requests. If you encounter problems or have ideas, these templates will help you provide the information we need to act quickly.

## A Note on Streaming

We've temporarily removed streaming output. The AI SDK v6 upgrade introduced some layout and flickering issues that affected the user experience. We're working on bringing streaming back in a future release once these issues are resolved.

## Breaking Changes

None! This is a drop-in upgrade.

## Get It Now

```bash
# npm
npm update -g @nanocollective/nanocoder

# homebrew
brew upgrade nanocoder

# nix
nix flake update
```

## Community

Nanocoder is built by a growing community of contributors. Special thanks to @DenizOkcu and @Avtrkrb for their contributions to this release.

Have feedback or found a bug? [Open an issue](https://github.com/nano-collective/nanocoder/issues)

---

_Nanocoder is a local-first AI coding agent that works with any OpenAI-compatible API. It's open source, privacy-respecting, and designed for developers who want AI assistance without vendor lock-in._

Nanocoder 1.18.0: Multi-Step Tool Calls, Better Debugging, and a Smarter Model Database

We're excited to share an overview of the recent Nanocoder releases, from the v1.16.x series through to v1.17.0. These releases represent huge community contributions, bug fixes, and significant new capabilities that make Nanocoder more powerful and user-friendly than ever.

## v1.16.0: The /usage Command and Better Tool Handling

The v1.16.0 release introduced a much-requested feature: the `/usage` command. Thanks to @spinualexandru, users can now visually monitor their model's context usage directly in the CLI. This closes issue #12 and gives developers better insight into how much of their context window is being consumed during sessions.

This release also expanded the model recommendations database with new models and fixed an important issue where models would occasionally request permission to call non-existent tools. The system now properly errors and loops back to allow the model to self-correct.

## v1.16.1: Quick Patch for Installation

A swift patch release addressed installation failures caused by a postinstall hook that referenced a missing scripts directory. The fix moved models.dev data fetching from installation time to first use, making installations smoother across all platforms.

## v1.16.2: Stability and Output Management

This release focused on stability improvements:

- **Empty response handling**: Models returning empty responses after tool execution are now automatically reprompted
- **False positive prevention**: HTML tags in responses no longer trigger incorrect tool call detection errors
- **Output limits**: `search_files` results capped at 10 (down from 50) and `execute_bash` output truncated to 2,000 characters to prevent context overflow

## v1.16.3: A Complete Tool System Overhaul

Version 1.16.3 brought substantial changes to how Nanocoder handles file operations and searching:

**Out with the old:**

- Removed `read_many_files` (rarely used over `read_file`)
- Removed `search_files` (models found it confusing)

**In with the new:**

- **`find_files`**: Pattern-based file and directory discovery
- **`search_file_contents`**: Content-aware searching with metadata
- **Revised `read_file`**: Now reveals progressive information, returning metadata first with optional line ranges for specific content

These changes were designed specifically to help smaller models like Qwen 3 Coder 30B perform better by reducing context rot through more purposeful tool calls.

Additional fixes included:

- Update checker rendering (previously appeared perpetually stuck)
- Proper XDG config path handling (`~/.config/nanocoder/`)
- Numerous edge-case fixes in the markdown parser
- Removal of message display limits (the optimised queue can now handle full session history)

## v1.16.4: Platform Improvements and New Theme

A community-driven release with several quality-of-life improvements:

- **Config/data separation**: Clear distinction between configuration and application data directories (thanks @bowmanjd)
- **Smart update detection**: The update checker now auto-detects your installation method (npm, Homebrew, Nix) and provides appropriate update instructions (thanks @fabriziosalmi)
- **Dracula theme**: A new dark theme option for Dracula enthusiasts
- **VSCode Terminal fixes**: Creating new lines and paste detection now work correctly in VSCode's integrated terminal
- **Better autocomplete**: Command autocomplete now selects the top suggestion rather than waiting for a single remaining option

## v1.16.5: Cleanup and Nix Fixes

The final patch in the 1.16.x series focused on refinement:

- `/init` command no longer generates `agents.config.json` (aligning with new configuration patterns)
- Code refactoring to reduce duplication (thanks @JimStenstrom)
- Critical fix for broken Nix installation (thanks @Thomashighbaugh)

---

## v1.17.0: VS Code Extension and MCP Overhaul

The v1.17.0 release marks a significant milestone for Nanocoder with two major features:

### VS Code Extension v1

Nanocoder now ships with an official VS Code extension featuring:

- **Live code diffs**: See changes as they're proposed
- **Diagnostics integration**: LSP support for language-aware feedback
- **Seamless workflow**: Work with Nanocoder directly in your editor

This is version 1 of the extension with plenty of room for expansion and improvement based on community feedback.

### MCP Configuration Redesign

Thanks to the extensive work by @Avtrkrb, the MCP (Model Context Protocol) system received a complete overhaul:

- **Tab-based UI**: Redesigned MCP configuration screens using a clean tab layout
- **Remote MCP support**: Added support for remote MCP servers alongside stdio servers
- **GitHub Remote MCP**: New template with Auth header configuration
- **Expanded templates**: Additional MCP server templates for common use cases
- **Better sequencing**: Configuration wizard now follows a logical stdio -> remote flow

### Additional Improvements

- Global configuration now properly loads when local/project configuration is missing
- Preflight checks and test improvements
- Documentation updates for new MCP fields

---

## Thank You to Our Contributors

These releases wouldn't be possible without our amazing community. Special thanks to:

- **@spinualexandru** - /usage command implementation
- **@bowmanjd** - Config/data directory separation and XDG path fixes
- **@fabriziosalmi** - Smart update detection
- **@Avtrkrb** - MCP configuration overhaul
- **@JimStenstrom** - Code refactoring
- **@Thomashighbaugh** - Nix installation fixes

## Get Started

Update to the latest version using your preferred method:

```bash
# npm
npm update -g @nanocollective/nanocoder

# Homebrew
brew update && brew upgrade nanocoder

# Nix
nix profile upgrade nanocoder
```

If you encounter any problems or have feedback, please drop an issue on [GitHub](https://github.com/Nano-Collective/nanocoder/issues) or message us through Discord.

Thank you for using Nanocoder!


Nanocoder v1.16.x to v1.17.0


**Status:** In Development Queue
**Issue:** [#52](https://github.com/Nano-Collective/nanocoder/issues/52)
**Priority:** High

## Overview

We're excited to announce that LSP (Language Server Protocol) support and IDE plugin implementation is up next in Nanocoder's development roadmap. This feature represents a significant leap forward in bringing deep code intelligence capabilities to our AI coding assistant.

## What's Coming?

The upcoming implementation will add comprehensive LSP support to Nanocoder, enabling it to leverage the same powerful code intelligence tools that modern IDEs use. This means the AI will have access to:

- **Real-time diagnostics** - Syntax errors, type checking, and linting issues
- **Code navigation** - Jump to definitions, find references, and symbol lookups
- **Type information** - Hover details and signature help
- **Intelligent refactoring** - Code actions, renaming, and completions
- **Workspace awareness** - Full understanding of project structure and dependencies

## Two-Part Approach

### Part 1: LSP Client in Nanocoder

The core enhancement will embed an LSP client directly into Nanocoder, automatically discovering and connecting to language servers in your development environment. This zero-configuration approach means:

- Auto-detection of installed language servers
- Support for multiple simultaneous connections (TypeScript, Python, Rust, etc.)
- 10 new AI tools powered by LSP data
- Graceful fallbacks when LSP isn't available

### Part 2: VS Code Extension

A dedicated VS Code extension will provide seamless IDE integration with:

- **Chat panel sidebar** - Interact with Nanocoder without leaving your editor
- **Editor integration** - Right-click context menus for quick AI assistance
- **File watching** - Bidirectional synchronization between VS Code and Nanocoder
- **Workspace awareness** - Full context of your project structure

## Design Philosophy

True to Nanocoder's ethos, LSP support will follow a zero-configuration philosophy. It should "just work" out of the box, with:

- Automatic detection of language servers
- No required configuration files or setup steps
- Intelligent fallbacks when LSP data isn't available
- Optional advanced configuration for power users

## Implementation Timeline

The development will follow a six-phase approach:

1. **LSP Foundation** - Core client implementation and auto-discovery
2. **Tools Integration** - New LSP-powered AI tools
3. **Context Enhancement** - Intelligent context building with LSP data
4. **Extension Server** - Communication bridge for IDE integration
5. **VS Code Extension** - Full-featured IDE plugin
6. **Testing & Polish** - Comprehensive testing and refinements

## Why This Matters

LSP support will fundamentally transform Nanocoder's capabilities. Instead of relying solely on file reading and text analysis, the AI will have access to the same rich semantic understanding that language servers provide to your IDE. This means:

- **More accurate suggestions** based on actual type information
- **Fewer errors** by leveraging real-time diagnostics
- **Better refactoring** with awareness of all symbol references
- **Faster development** with IDE-integrated workflows

## Get Involved

This is an ambitious feature that will take Nanocoder to the next level. We're starting development soon and would love community input:

- Share your thoughts on the [GitHub issue](https://github.com/Nano-Collective/nanocoder/issues/52)
- Suggest additional LSP capabilities you'd like to see
- Help us prioritize which language servers to support first

Stay tuned for updates as we begin implementation!

---

*Nanocoder is a local-first AI coding assistant built with React and Ink.js, supporting multiple LLM providers including Ollama, OpenRouter, and OpenAI-compatible APIs.*


Next Up: LSP Support & IDE Plugin Implementation

We're excited to announce an upcoming feature for `@nanocollective/get-md`: optional AI-powered HTML to Markdown conversion using locally-run language models. This enhancement will give developers the choice between lightning-fast conversion and AI-enhanced quality, all while maintaining complete offline functionality.

## The Challenge

While our current Turndown-based conversion is fast and reliable (sub-100ms for most pages), complex HTML structures like nested tables, intricate layouts, and heavily formatted content can sometimes result in less-than-perfect Markdown output. We wanted to offer a solution that could handle these edge cases better without forcing all users to adopt a slower, more resource-intensive approach.

## The Solution: Optional Local LLM

We're adding support for ReaderLM-v2, a 1.5 billion parameter language model specifically designed for HTML-to-Markdown conversion. The key aspects of our approach:

- **Completely optional**: Turndown remains the default. Users opt-in via a simple flag.
- **Runs locally**: No API keys, no cloud services, no internet required (after model download).
- **Full control**: Developers using get-md in their applications can let their end-users decide whether to enable AI conversion.
- **Smart fallback**: If the LLM fails for any reason, the system automatically falls back to Turndown.

## How It Works

### For CLI Users

```bash
# Check if the model is available
getmd --model-info

# Download the AI model (986MB, one-time)
getmd --download-model

# Convert using AI
getmd https://example.com --use-llm
```

The CLI provides interactive prompts and progress bars to guide users through the model download process.

### For SDK/Package Users

```typescript
import {
  convertToMarkdown,
  checkLLMModel,
  downloadLLMModel
} from '@nanocollective/get-md';

// Check if model is available
const status = await checkLLMModel();

if (!status.available) {
  // Download with progress callbacks
  await downloadLLMModel({
    onProgress: (downloaded, total, percentage) => {
      console.log(`Downloading: ${percentage.toFixed(1)}%`);
    }
  });
}

// Convert with AI
const result = await convertToMarkdown('https://example.com', {
  useLLM: true,
  onLLMEvent: (event) => {
    // React to conversion events
    if (event.type === 'conversion-complete') {
      console.log(`Done in ${event.duration}ms`);
    }
  }
});
```

## Perfect for Application Developers

One of the most powerful aspects of this feature is how it works for developers building applications with get-md. Whether you're creating an Obsidian plugin, VS Code extension, Electron app, or web service, you can give your users the choice to enable AI conversion.

### Example: Obsidian Plugin

```typescript
// In your plugin settings
new Setting(containerEl)
  .setName('AI-powered conversion')
  .setDesc('Better quality, slower (986MB model)')
  .addToggle(toggle => toggle
    .setValue(this.settings.useAI)
    .onChange(async (value) => {
      this.settings.useAI = value;
      await this.saveSettings();
    }));

// Add a download button if model isn't installed
if (!modelAvailable) {
  new Setting(containerEl)
    .addButton(button => button
      .setButtonText('Download AI Model')
      .onClick(async () => {
        await downloadLLMModel({
          onProgress: (_, __, percentage) => {
            button.setButtonText(`Downloading... ${percentage}%`);
          }
        });
      }));
}
```

Your users get a seamless experience with progress feedback, and the model downloads directly to their machine—no server-side infrastructure needed on your end.

## Performance Trade-offs

We believe in transparency, so here's what you need to know:

| Metric | Turndown (Default) | LLM (Optional) |
|--------|-------------------|----------------|
| **Speed** | <100ms | 5-10 seconds |
| **RAM** | ~100MB | 2-4GB |
| **Disk** | 0MB | 986MB (model) |
| **Quality** | Good | Excellent |
| **Complex layouts** | Good | Excellent |
| **Consistency** | 100% deterministic | ~95% consistent |

### When to Use Each

- **Use Turndown** (default) for:
  - Batch processing thousands of pages
  - CI/CD pipelines
  - Real-time conversion
  - Low-resource environments
  - Simple blog posts and articles

- **Use LLM** (opt-in) for:
  - High-quality single conversions
  - Complex documentation sites
  - Pages with intricate tables and nested structures
  - When visual fidelity matters most

## Technical Architecture

The LLM integration is designed to enhance, not replace, the existing pipeline:

1. **Content extraction** (Readability) - removes ads, nav, etc.
2. **HTML cleaning** - removes scripts, normalizes structure
3. **Structure enhancement** - fixes heading hierarchy
4. **Conversion** - Either Turndown OR LLM (user's choice)
5. **Post-processing** - adds frontmatter, calculates stats

By running the LLM on pre-cleaned HTML, we get better results while reducing token usage and processing time.

## Callback System for Rich UIs

We've designed a comprehensive callback system so developers can build rich user interfaces around the conversion process:

```typescript
await convertToMarkdown(url, {
  useLLM: true,
  onLLMEvent: (event) => {
    switch (event.type) {
      case 'model-loading':
        showSpinner('Loading AI model...');
        break;
      case 'download-progress':
        updateProgressBar(event.percentage);
        break;
      case 'conversion-complete':
        hideSpinner();
        showSuccess(`Converted in ${event.duration}ms`);
        break;
      case 'fallback-start':
        showWarning('Using fallback method');
        break;
    }
  }
});
```

This means whether you're building a CLI tool, desktop app, or web service, you can provide users with real-time feedback on what's happening.

## Why ReaderLM-v2?

We chose ReaderLM-v2 for several reasons:

- **Purpose-built**: Specifically designed for HTML-to-Markdown conversion
- **Efficient**: 1.5B parameters with GGUF quantization (Q4_K_M) runs on consumer hardware
- **Multilingual**: Supports 29 languages out of the box
- **Proven**: Outperforms much larger models on conversion tasks
- **Open source**: Available on Hugging Face, MIT-compatible licensing

The Q4_K_M quantized version strikes the perfect balance—high quality at 986MB, running comfortably on systems with 8GB+ RAM.

## Open Questions & Future Enhancements

We're considering several enhancements for future versions:

- **Hybrid mode**: Use LLM only for complex sections (tables, nested structures), Turndown for simple content
- **GPU acceleration**: Faster inference on compatible hardware
- **Caching layer**: Store conversions to avoid re-processing identical content
- **Alternative models**: Support for other models based on user preference
- **Smart detection**: Automatically choose method based on HTML complexity

We'd love to hear your feedback on which features would be most valuable to you.

## No Breaking Changes

This is a purely additive feature. All existing code continues to work exactly as before. The default behavior remains unchanged—fast, deterministic Turndown conversion. LLM conversion is opt-in only.

## Try It Out

The implementation is currently in planning stages. We're working through the architecture and will be rolling this out in phases:

- **Phase 1**: Core infrastructure and LLM integration
- **Phase 2**: CLI and SDK integration with callbacks
- **Phase 3**: Enhanced features (model management, config files)
- **Phase 4**: Comprehensive testing and documentation

Follow our [GitHub repository](https://github.com/nano-collective/get-md) for updates, or check out [Issue #3](https://github.com/Nano-Collective/get-md/issues/3) to join the discussion.

## We Want Your Feedback

This feature is being designed with the community in mind. We'd love to hear:

- What use cases would benefit most from AI-powered conversion?
- What should the user experience look like in your application?
- Are there specific models or configurations you'd like to see supported?
- What concerns do you have about the implementation?

Join the conversation on GitHub or reach out to us directly. Let's build something amazing together.

---

*get-md is an open-source HTML to Markdown converter optimized for LLM consumption, built by the Nano Collective. Fast, reliable, and now with optional AI enhancement.*


Package

New Concept

Draft

Introducing AI-Powered HTML to Markdown Conversion in get-md

# Nanocoder Recent Updates: v1.15.0 to v1.16.4

Here's what's been happening with Nanocoder lately! We've been busy shipping some pretty cool stuff from v1.15.0 to v1.16.4 - including a complete backend overhaul, new features for tracking context usage and tagging files, tool system refinements for better context management, configuration directory improvements, and a bunch of important fixes to make everything run smoother. Let's dive in.

## v1.16.4 - Configuration, Updates & Input Handling

**Release Focus**: Configuration/data separation, intelligent update detection, and improved terminal compatibility

### New Features

**New**: Dracula theme added to the theme selector

### Major Changes

**Big**: Decoupled configuration vs data directories to introduce clear separation between configuration and application data directories (contributed by @bowmanjd) 🎉

- Config now lives in platform-specific config directories (e.g., `~/.config/nanocoder/`)
- Data stored separately in platform-specific data directories
- Optional `NANOCODER_DATA_DIR` environment variable for custom data location
- Automatic migration from old paths with user feedback

**Big**: Update checker now intelligently detects how you installed Nanocoder and provides appropriate update instructions (contributed by @fabriziosalmi)

- Auto-detects installation method (npm, Homebrew, Nix, etc.)
- Shows correct update commands based on detection
- Provides manual update steps if auto-detection fails

### Fixes

**Fix**: Command auto-complete now auto-completes to the top suggestion regardless of how many matches exist (previously only worked with single match)

**Fix**: Improved paste detection to create placeholders for any pasted content (removed 80-char minimum), fixed consecutive paste placeholder sizing, and improved paste chunking for VSCode and other terminals

**Fix**: Creating new lines in VSCode Terminal was broken - now fully functional

**Fix**: History navigation issues resolved

---

## v1.16.3 - Tool System Overhaul

**Release Focus**: Context management optimization and tool refinement for smaller models

### Major Changes

**Big**: Complete tool system redesign to better manage context and improve accuracy for smaller models like Qwen 3 Coder 30B

### New Tools

**New**: `find_files` tool - Model provides a pattern and gets back matching files and directory paths

**New**: `search_file_contents` tool - Model provides a pattern and gets back matching content with metadata for further use

### Tool Improvements

**Enhanced**: `read_file` tool now reveals progressive information about files

- Called alone: Returns just file metadata
- With line number ranges: Returns specific content
- Reduces unnecessary context loading

### Removed Tools

**Removed**: `read_many_files` tool - Rarely used by models over `read_file` with little benefit

**Removed**: `search_files` tool - Models often found it confusing when trying to differentiate finding files vs searching content

### Enhancements

**Enhancement**: Removed message display limit - You can now see entire session history (message queue is well optimized)

**Enhancement**: Many edge-case fixes in the markdown parser for assistant messages - Outputs are far cleaner now

### Fixes

**Fix**: Update checker used old rendering method so appeared broken and always checking for an update - Now fully functional

**Fix**: Config files now correctly use `~/.config/nanocoder/` (or platform equivalents) instead of `~/.local/share/nanocoder/`, restoring proper XDG semantic separation between configuration and data (contributed by @bowmanjd)

---

## v1.16.2 - Output Management & Parsing Improvements

**Release Focus**: Enhanced tool output handling and model response reliability

### Fixes

**Fix**: Models returning empty responses after tool execution now automatically reprompted

**Fix**: HTML tags in responses no longer trigger false tool call detection errors

### Enhancements

**Enhancement**: `search_files` tool limited to 10 results (reduced from 50) to prevent large outputs

**Enhancement**: `execute_bash` output truncated to 2,000 chars (reduced from 4,000) and returns plain string

**Enhancement**: Model context limit tests updated to match actual implementation

---

## v1.16.1 - Installation Fix

**Release Focus**: Resolving installation issues for better package reliability

### Fixes

**Fix**: Removed postinstall hook that caused installation failures when scripts directory was missing from published package

**Change**: Models.dev data now fetched on first use instead of during installation

---

## v1.16.0 - Usage Tracking & Stability

**Release Focus**: Context usage visibility and tool calling reliability

### New Features

**New**: `/usage` command for visualizing model context usage (contributed by @spinualexandru, closes #12) 🎉

### Enhancements

**Enhancement**: Added new models to recommendations database

### Fixes

**Fix**: Resolved issue where model requested permission for non-existent tools - Now errors and loops back to the model to self-correct

---

## v1.15.1 - Compatibility Fixes

**Release Focus**: Cross-platform compatibility and edge case handling

### Fixes

**Fix**: Ollama tool calls without IDs no longer cause empty responses - IDs now auto-generated when missing

**Fix**: Homebrew installer now working correctly

**Fix**: Node version requirement updated to 20+

---

## v1.15.0 - Major Architecture Update

**Release Focus**: Backend modernization and enhanced user experience

### Major Changes

**Big**: Switched backend architecture from LangGraph to AI SDK - A better fit for Nanocoder (contributed by @DenizOkcu)

### New Features

**New**: File tagging with `@` symbol - Fuzzy search and select files to include in messages directly

**New**: Real-time message streaming to see agent respond in realtime - Toggle stream mode on/off via the `/streaming` command

**New**: Homebrew installation option

### Enhancements

**Enhancement**: Command auto-complete now uses fuzzy search for better discoverability

**Enhancement**: Replaced custom table renderer with the more robust `cli-table3` library

**Enhancement**: Refined XML/JSON parsing flow for non-native tool calls

---

## Summary

These releases demonstrate Nanocoder's commitment to:

**Stability**: Critical fixes for installation, tool calling, terminal compatibility, and cross-platform support

**Performance**: Architectural improvements with AI SDK migration, optimized context management, and refined tool system

**User Experience**: New features like context usage tracking, file tagging, real-time streaming, intelligent update detection, and improved configuration management

**Community**: Multiple contributor acknowledgments (@spinualexandru, @DenizOkcu, @bowmanjd, @fabriziosalmi) and continued focus on user feedback

The journey from v1.15.0 to v1.16.4 represents both major architectural milestones (AI SDK migration, tool system overhaul, config/data separation) and incremental refinements based on real-world usage and community feedback. Special focus on making Nanocoder work better with smaller models through intelligent context management shows our commitment to accessibility and performance across all hardware configurations.

---

Want to get involved? Drop a comment or an issue on the relevant repo 😎


Nanocoder Recent Releases Overview – v1.15.0 -> v1.16.0

One of the next things up for Nanocoder is official Homebrew support. This has been our _longest_ open issue so we thought we'd better get to it 😉

### What this means for you:
Installing and updating Nanocoder will be as simple as:

```bash
brew install Nano-Collective/nanocoder/nanocoder
```
### Key benefits:
- Streamlined installation for macOS and Linux users
- Automatic updates with each new release
- Standardized package management that integrates with your existing workflow
- One-command upgrades to always stay current

### What we're building:

- Native Homebrew formula in our main repository
- Automated formula updates with every release
- Comprehensive documentation and troubleshooting guides
- Rigorous testing across multiple macOS versions

This addition makes Nanocoder even more accessible while maintaining our commitment to local-first, privacy-respecting AI tools.

Stay tuned for the official release.

New Feature Development: Homebrew Installation Support 🍺

### Update: Adding @ File Syntax to Nanocoder

Next up for Nanocoder, we'll be working on `@` syntax for file references, based on the feature request in issue #5.

### What's changing:
You'll be able to include files directly in your messages using `@` syntax. Instead of asking Nanocoder to read files separately, you can reference them inline:

`"Fix the TypeScript errors in @src/utils/validation.ts and update @types/user.ts accordingly"`

### Planned features:

- File inclusion with @filename.ts
- Line range support with @filename.ts:10-20
- Multiple file references in one message
- Tab completion for file paths
- Glob pattern support

This should streamline your workflow by reducing the steps needed to work with multiple files.

We'll share another discussion once released!

New Feature Development: Adding @ File Syntax to Nanocoder

# New Package: LLM Scorer / Profiler / Bench based on system

In [Nanocoder](https://github.com/Nano-Collective/nanocoder) we offer LLM recommendations via a [`/recommendations` command](https://github.com/Nano-Collective/nanocoder/issues/43). This has proven useful for users to see how well a particular LLM will run on a system.

We're taking this idea and building an isolated package that takes in a list of models and system information, returning a series of metrics for each model and an overall performance score.

## How it might work...

This package produces metrics for each model, based on...

- User's system information (memory, CPU, GPU, TPU, Swap, Arch, ...)
- LLM's model card information (arch, quant, ...)
- LLM's skills (vision, tools, ...)

... then rate how well the LLM operates on the user's system.

Primarily this package will be used to rate local LLMs on the runtime's system, but we also see merits in scoring skills and allowing you to override system information too. We also need to consider when the list of models features entries that are cloud-side, meaning system information doesn't weigh in nearly as much.

Usage may look something like this:

```typescript
const result = llmScorer({
    models: [
        {
            model: 'meta-llama/Llama-3.1-8B',
            quantization: ...,
            arch: 'llama',
            // Many other optional parameters for this model...
        },
        {
            model: 'meta-llama/Llama-3.2-1B',
            quantization: ...,
            arch: 'llama',
        },
    ],
    system: {
        // optionally override default behaviour of pulling system information
        memoryGB: 24,
        // ...
    }
})
```

And the results will look something like this, ordered by best rated model first:

```
[
    {
        model: "meta-llama/Llama-3.1-8B",
        score: 0.8,
        metrics: {
            ...
        }
    },
    {
        ...
    },
]
```

# What Next

We're in the process of building an initial solution and plan to release this on a public repository to gather feedback from our community and evolve it.

We recognise that there's many angles and opinions to consider for this, so we welcome contributors and our community to help form how this package works.

We'll announce the alpha version of this package once it is prepared and released.

# Community
We're a small community-led team building local and privacy-first AI solutions under the [Nano Collective](https://nanocollective.org/) and would love your help! Whether you're interested in contributing code, documentation, or just being part of our community, there are several ways to get involved.

**If you want to contribute to this new concept:**

- Drop comments and thoughts below, or [join our Discord server](https://discord.gg/ktPDV6rekE)

**If you want to be part of our community or help with other aspects like code, design or marketing:**

- Join our Discord server to connect with other users, ask questions, share ideas, and get help: [Join our Discord server](https://discord.gg/ktPDV6rekE)

- Head to our GitHub issues or discussions to open and join current conversations with others in the community.


New Package: LLM Scorer / Profiler / Bench based on system

# New Package: Lightweight HTML to Markdown utility for LLM use

Our members saw the sheer speed of [Markitdown](https://github.com/microsoft/markitdown) in the Python space, so we begun to wonder what lessons we could bring to the Node JS space, with LLM use in mind.

---

**Now Released**: new LLM oriented utility for converting HTML to Markdown - [@nanocollective/get-md](https://github.com/Nano-Collective/get-md)

---

For speed, markdown is often a preferable format for LLMs to digest content. So when you want to process a webpage, converting it to markdown helps strip out anything but the relevant content an LLM needs to perform a job.

We produced a binary version of Markitdown that can be bundled into a Node JS package (see [@mote-software/markitdown](https://github.com/Mote-Software/markitdown)) but the cold-boot performance hit is much worse than we hoped. We'll explore options to speed this up, but ultimately using binaries  - especially Python based - will always have a degraded performance.

So with a focus on speed and quality, this new Node JS package can take in HTML and produce a markdown format optimised for LLM use within moments (~100ms), and save you magnitudes of compute.

> [!TIP]
> We'd like to bring more input formats too, so you could convert PDF, DOCX, audio, and other file formats... just like [Markitdown](https://github.com/microsoft/markitdown) does. [We welcome contributors](https://github.com/Nano-Collective/get-md/blob/main/CONTRIBUTING.md) to help our community with this mission.

# Community
We're a small community-led team building local and privacy-first AI solutions under the [Nano Collective](https://nanocollective.org/) and would love your help! Whether you're interested in contributing code, documentation, or just being part of our community, there are several ways to get involved.

**If you want to contribute to the code:**

- Read our detailed [CONTRIBUTING.md](https://github.com/Nano-Collective/get-md/blob/main/CONTRIBUTING.md) guide for information on development setup, coding standards, and how to submit your changes.

**If you want to be part of our community or help with other aspects like design or marketing:**

- Join our Discord server to connect with other users, ask questions, share ideas, and get help: [Join our Discord server](https://discord.gg/ktPDV6rekE)

- Head to our GitHub issues or discussions to open and join current conversations with others in the community.

Nano Collective

Our Mission

Nanocoder

Nanotune

Featured Packages

What's Next

Get Involved