Onetool MCP

OneTool is a unified MCP server that exposes over 100 tools through the Python API, significantly reducing token consumption and cost when AI calls tools, avoiding context pollution, and supporting multiple functions such as web search, database, file operations, and chart drawing.

Developer tools Search tools #Unified Tool Platform #Cost Optimization #Code Execution #Multi - Tool Integration .Python

rating : 2.5 points

downloads : 6.9K

update time : 2026-03-12

Open Site

What is OneTool MCP?

OneTool is an innovative Model Context Protocol (MCP) server that integrates over 100 development tools into a unified Python API. Different from traditional MCP servers, OneTool allows AI assistants to call tools by writing code instead of loading all tool definitions in each conversation, thus significantly reducing token consumption and context pollution.

How to use OneTool MCP?

After installing OneTool, configure it as the server for Claude Code or other MCP clients. AI assistants can call various tools, such as search, file operations, database queries, etc., by writing Python code. Users only need to configure it once to access all tools.

Use cases

OneTool is particularly suitable for AI assistant scenarios that require frequent use of multiple tools, such as code development, data analysis, document processing, web search, system management, etc. It solves the problems of high token consumption and context pollution caused by connecting multiple tools in traditional MCP servers.

Main Features

96% Token Savings

Regardless of how many tools are added, each request only consumes about 2K tokens, which is significantly lower than traditional MCP servers (3K - 30K tokens per server).

Unified Python API

Provides over 100 tools through a single Python API. AI assistants call tools by writing code instead of loading all tool definitions in the context.

Dynamic AWS Integration

Proxy all 57+ AWS Lab MCP servers and automatically handle SSO and credential management without the need to configure each AWS service separately.

Real-time Whiteboard

Draw charts on Excalidraw through a Mermaid-compatible DSL, supporting real-time collaboration and visualization.

MCP Server Proxy

Wrap existing MCP servers and call them through code instead of loading tool definitions, avoiding the tool tax problem.

Encrypted Secret Management

Use an age-encrypted secrets.yaml file, supported by the operating system key store, to securely store API keys and credentials.

Image Vision Processing

Process images through a dedicated model, supporting multiple sources such as local files, URLs, and clipboards, with formats including PNG, JPEG, GIF, WebP, etc.

Intelligent Context Storage

Use SQLite + FTS5 to store and retrieve large outputs, allowing you to search and navigate content without filling the context window.

Tool Forging Capability

Create new tools during the conversation to expand the function set of OneTool and meet specific needs.

Advantages

Significantly reduce token consumption: Reduce token usage by 96% compared to traditional MCP servers.

Avoid context pollution: Tool definitions are not loaded into the conversation context, maintaining the intelligence level of the AI assistant.

Cost-effective: Significantly reduce the monthly cost of using AI assistants.

Unified management: Manage all tools with one configuration, simplifying setup and maintenance.

High scalability: Easy to add new tools and customize functions.

High security: Multi-layer security protection, including AST verification, path boundaries, and output cleaning.

Limitations

Learning curve: AI assistants need to be able to write Python code to call tools.

Initial configuration: All tools and credentials need to be configured once.

Dependence on Python environment: It needs to run in an environment that supports Python.

Tool coverage: Although over 100 tools are provided, it may not include some specialized tools in specific fields.

How to Use

Install Dependencies

First, install the uv package manager, which is a prerequisite for installing OneTool.

Install OneTool

Use uv to install the OneTool MCP server and all its dependencies.

Initialize Configuration

Initialize the OneTool configuration file, create necessary directories and default settings.

Configure Claude Code

Add OneTool as the MCP server for Claude Code.

Verify Installation

Verify that OneTool is installed and configured correctly.

Usage Examples

Web Search and Information Collection

Use OneTool to conduct web searches and collect the latest technical documents and information.

File Processing and Data Analysis

Read an Excel file, analyze the data, and generate a report.

Image Content Analysis

Analyze the content of an image and answer questions about the image.

Database Operations

Connect to a database, execute queries, and obtain business data.

Chart Drawing

Create a visual chart based on data.

Frequently Asked Questions

What is the difference between OneTool and traditional MCP servers?

Do I need programming knowledge to use OneTool?

Which AI assistants does OneTool support?

How to add custom tools?

Is OneTool secure?

Can I disable the telemetry function?

Which databases does OneTool support?

How to get support if I encounter problems?

Related Resources

Official Documentation

Complete OneTool documentation, including installation guides, configuration instructions, tool references, etc.

GitHub Repository

OneTool's source code, issue tracking, and contribution guidelines.

Quick Start Guide

A quick guide to start using OneTool in 30 seconds.

Tool Reference

Detailed reference documentation for all over 100 tools.

Anthropic Engineering Blog

Anthropic's engineering blog about MCP code execution, explaining the design concept of OneTool.

Chroma Context Pollution Research

Research on the AI context pollution problem, explaining the problems solved by OneTool.

Support Developers

Support the development of OneTool through Ko-fi.

🚀 One MCP for Developers

🧿 One MCP for developers - No tool tax, no context rot. 100+ tools including Brave, Google, Context7, Excalidraw, AWS, Version Checker, Excel, File Ops, Database, Image Vision, Playwright & Chrome DevTools Utils and many more. Works with Claude Code or any MCP client.

🚀 Quick Start

The Problem

Each MCP server consumes 3K - 30K tokens per request. Connect 5 servers and you've burned 55K tokens before the conversation starts. Connect 10+ and you're at 100K tokens.

The math is brutal: Claude Opus 4.5 at $5/M input tokens, 20 days × 10 conversations × 10 messages × 3K tokens = $30/month per MCP server - even if you never use the tools.

And then there's context rot - your AI literally gets dumber as you add more tools (Chroma Research, 2025).

The Solution

OneTool is one MCP server that exposes tools as a Python API. Instead of reading tool definitions, your agent writes code:

>>> brave.search(query="react docs 2026")

Configure one MCP server. Use unlimited tools.

"Agents scale better by writing code to call tools instead. This reduces the token usage from 150,000 tokens to 2,000 tokens...a cost saving of 98.7%"

— Anthropic Engineering

96% fewer tokens. 30× lower cost. No context rot.

📖 Read the full story

📦 Installation

Requires uv:

uv tool install 'onetool-mcp[all]'   # everything
onetool init -c ~/.onetool

Add to Claude Code:

claude mcp add onetool -- onetool --config ~/.onetool/onetool.yaml

Or manually add to ~/.claude/mcp.json:

{
  "mcpServers": {
    "onetool": {
      "command": "onetool",
      "args": ["--config", "/Users/yourname/.onetool/onetool.yaml"]
    }
  }
}

That's it. All 100+ tools work out of the box.

Verify: onetool init validate -c ~/.onetool/onetool.yaml

📖 Full installation guide

✨ Features

Property	Details
96% Token Savings	~2K tokens no matter how many tools you add
100+ Built-in Tools	Web search, AWS, databases, file ops, diagrams, conversions
Explicit Execution	See exactly what runs — `>>> brave.search(q="AI")`
Dynamic AWS	Proxy all 57+ AWSlabs MCP servers; SSO and credentials handled
Live Whiteboard	Draw diagrams with a Mermaid-compatible DSL via Excalidraw
MCP Server Proxy	Wrap existing MCP servers without the tool tax
Encrypted Secrets	age-encrypted `secrets.yaml` backed by your OS keychain
Forge Tools	Build new tools as part of the conversation
Image Vision	Routes to a cheaper, better vision model via `ot_image` (`img`). Zero host tokens. Supports local files, URLs, clipboard; PNG, JPEG, GIF, WebP, TIFF, HEIC, AVIF, SVG.
Smart Context	`ot_context` (`ctx`) — SQLite+FTS5 store. Search and navigate large outputs without filling the context window.
Smart Tools	Delegate to cheaper LLMs (10× savings)
Security Layers	AST validation, path boundaries, output sanitisation

💻 Usage Examples

Basic Usage

>>> brave.search(query="react docs 2026")

Advanced Usage

>>> mcp.call(server="github", tool="get_file_contents", arguments={"path": "README.md"})

📚 Documentation

Quickstart - 30 seconds to first tool call
Installation - All platforms
Configuration - YAML schema
Tools Reference - All 100+ tools
Security - Security layers
Extending - Build your own
Dev Docs - Internal developer documentation
Specifications - OpenSpec specifications index

🔧 Technical Details

Tools

27+ packs, 230+ tools ready to use:

Pack	Tools	Extra	Description
`aws`	`whoami`, `login`, `start_packs`, `roles`	`[dev]`	Dynamic AWS proxy (57+ servers)
`brave`	`search`, `news`	`[util]`	Web and news search
`chrome_util`	`highlight_element`, `guide_user`	`[dev]`	Browser annotations (DevTools)
`context7`	`search`, `doc`	`[dev]`	Library documentation
`convert`	`pdf_to_md`, `docx_to_md`, `pptx_to_md`	`[util]`	Document conversion
`db`	`query`, `schema`, `tables`	`[dev]`	Database operations
`diagram`	`create`, `get_playground_url`	`[dev]`	Mermaid / Kroki diagrams
`excel`	`read`, `write`, `query`	`[util]`	Excel files
`file`	`read`, `write`, `grep`, `slice`, `toc`	`[util]`	File operations
`ground`	`search`	`[util]`	Google Grounding search
`mem`	`write`, `read`, `search`, `grep`	`[util]`	Persistent memory
`ot_forge`	`create_ext`, `validate_ext`, `install_skills`		Scaffold new tool packs
`ot_context` (`ctx`)	`write`, `read`, `search`, `grep`, `slice`, `toc`		Smart context store (SQLite+FTS5)
`ot_image` (`img`)	`load`, `load_batch`, `ask`, `summary`, `list`, `delete`, `purge`	`[util]`	Image vision via dedicated model
`ot_llm`	`transform`, `transform_file`		LLM-powered transforms
`ot_secrets`	`init`, `encrypt`, `audit`, `rotate`		Secrets encryption
`ot_timer`	`start`, `elapsed`, `list`		Named timers
`ot`	`help`, `tools`, `stats`, `skills`		Introspection
`package`	`npm`, `pypi`, `cargo`	`[dev]`	Package versions
`play_util`	`highlight_element`, `guide_user`	`[dev]`	Browser annotations (Playwright)
`ripgrep`	`search`, `count`	`[dev]`	Fast code search
`tavily`	`search`, `search_batch`, `research`	`[util]`	AI-native search
`webfetch`	`fetch`, `fetch_batch`	`[dev]`	Web fetching
`whiteboard`	`open`, `draw`, `screenshot`, `save`	`[dev]`	Live Excalidraw canvas
`worktree`	`add`, `commit`, `diff`, `remove`	`[dev]`	Parallel agent git worktrees

📖 Complete tools reference — full summary table with all 230+ tools

MCP Server Proxy

Wrap any existing MCP server and call it explicitly - simple yaml config without the tool tax:

# .onetool/onetool.yaml
servers:
  chrome_devtools:
    type: stdio
    command: npx
    args: ["-y", "@anthropic-ai/chrome-devtools-mcp@latest"]
  github:
    type: stdio
    command: npx
    args: ["-y", "@anthropic-ai/github-mcp-server@latest"]

Extending

Drop a Python file, get a pack. No registration, no config:

# .onetool/tools/wiki.py
pack = "wiki"

def summary(*, title: str) -> str:
    """Get Wikipedia article summary."""
    import httpx
    url = f"https://en.wikipedia.org/api/rest_v1/page/summary/{title}"
    return httpx.get(url).json().get("extract", "Not found")

📄 License

GPLv3

📋 References

Code Execution with MCP - Anthropic Engineering
Context Rot - Chroma Research

📊 Telemetry

OneTool sends anonymous startup pings (event type, version, OS). No personal data. Opt out: export DO_NOT_TRACK=1 or set telemetry.enabled: false in onetool.yaml. Details