MCP代码模式库

from mcp_codemode import mcp
result = await mcp.filesystem.read_file(path="/etc/hosts")

{
  "mcpServers": {
    "codemode": {
      "command": "python",
      "args": ["-m", "mcp_codemode.server_main"],
      "transport": "stdio"
    }
  }
}

Traditional:  ~10,000 tokens (all tools loaded)
Code Mode:    ~200 tokens (lazy loading + local processing)

uv add mcp-codemode-py
# or
pip install mcp-codemode-py

from mcp_codemode import mcp

# Direct tool call - schema loads automatically
result = await mcp.filesystem.read_file(path="/etc/hosts")

# Multi-step with local processing (no context overhead!)
files = await mcp.filesystem.list_directory(path="/var/log")
large_files = [f for f in files if f['size'] > 1_000_000]

for file in large_files[:10]:
    content = await mcp.filesystem.read_file(path=file['path'])
    # Process locally - doesn't bloat context

# Only return what matters
return {"count": len(large_files), "sample": large_files[:3]}

# Discover servers
servers = await mcp.list_servers()

# Discover tools on a server
tools = await mcp.github.list_tools()

# Search across everything
results = await mcp.search("create issue")
# -> [SearchResult(server="github", tool="create_issue", score=0.95)]

# Use the results
await mcp.github.create_issue(repo="...", title="...", body="...")

# Generate .pyi stub files for IDE support
mcp-codemode stub-gen

# List available servers
mcp-codemode list

# Search for tools
mcp-codemode search "file operations"

# List tools for a server
mcp-codemode tools github --detailed

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/files"],
      "transport": "stdio"
    },
    "github": {
      "command": "mcp-server-github",
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
      },
      "transport": "stdio"
    }
  }
}

# Generate stubs
mcp-codemode stub-gen

.codemode/
  stubs/
    filesystem/
      __init__.pyi
      read_file.pyi
      write_file.pyi
    github/
      create_issue.pyi
      list_repos.pyi

Level 0: Start with just `mcp` object (0 tokens)
   |
Level 1: Discover servers when needed (~20 tokens)
   |
Level 2: Discover tools on server (~50 tokens)
   |
Level 3: Load schema on tool call (0 context tokens)

# Automatic validation from JSON Schema
await mcp.filesystem.read_file(path="/etc/hosts")  # OK

# Validation catches errors
await mcp.filesystem.read_file(path=123)  # ValueError

+------------------+
|   Your Code      |
+--------+---------+
         |
+--------v---------+
|  MCP Code Mode   |  <- Pydantic validation
|                  |  <- Lazy loading
|                  |  <- Progressive disclosure
+--------+---------+
         |
+--------v---------+
|   MCP SDK        |  <- Official MCP client
+--------+---------+
         |
+--------v---------+
|  MCP Servers     |  <- filesystem, github, etc.
+------------------+

results = await mcp.search("file operations")
# Matches against tool names and descriptions

from mcp_codemode import mcp
# Background: generates .codemode/stubs/ automatically

mcp-codemode stub-gen

from mcp_codemode import mcp

# Claude Code naturally:
# 1. Uses Glob to find available tools
# 2. Uses Grep to search by keyword
# 3. Uses Read to view schemas
# 4. Calls tools with validation

result = await mcp.github.create_issue(...)

from anthropic import Anthropic
from mcp_codemode import mcp

client = Anthropic()

# Claude writes code that uses mcp
code = """
files = await mcp.filesystem.list_directory(path='/var/log')
large = [f for f in files if f['size'] > 1_000_000]
return large[:5]
"""

# Execute in your environment
# (with mcp available)

# One tool call that uses multiple servers!
{
  "tool": "execute_code",
  "arguments": {
    "code": "files = await mcp.filesystem.list_directory(path='.')\nlarge = [f for f in files if f['size'] > 1_000_000]\nissue = await mcp.github.create_issue(repo='user/repo', title=f'{len(large)} large files')\nreturn {'issue': issue['number']}"
  }
}