# 1. Clone repository
git clone https://github.com/simpletoolsindia/extra_skills_mcp_tools.git
cd extra_skills_mcp_tools

# 2. Run installation script
./install-claude-code.sh

# 3. Restart Claude Code
claude

# 4. Verify installation
docker compose -f docker-compose.local.yml ps

# Before: Fetch raw HTML (~8000 tokens)
fetch("https://example.com")  # Returns bloated HTML

# After: Optimized fetch (~300 tokens)
quick_fetch(url="https://example.com", max_tokens=1500)
# Returns: {title: "Example", summary: "...", tokens: 300}

# Store large outputs externally (98% reduction)
ctx_store_output(
    tool_name="github_repo",
    arguments={"owner": "anthropics"},
    output={"repo": "claude-code", "stars": 15000}
)
# Returns: {"ref": "@ctx:default:abc123", "size_bytes": 54}
# Instead of storing 500+ tokens, just store the reference

# Model Settings
claude config set --claude-code-subagent-model sonnet
export HAIKU_MODEL=haiku

# Thinking Token Limit (~70% savings)
# Default: 32,000 tokens
# Recommended: 10,000 tokens
export MAX_THINKING_TOKENS=10000

# Compaction Settings (better performance)
# Default: 95% context before compact
# Recommended: 50% for more working room
export CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=50

# MCP Server Limit
# Keep under 10 MCP servers, 80 total tools
# More = reduced effective context window

┌─────────────────────────────────────────────────────────────────┐
│                      Claude Code                                  │
│  ┌───────────────────────────────────────────────────────────┐  │
│  │  MCP Servers (< 10 recommended)                            │  │
│  │                                                            │  │
│  │  • mcp-server (83 tools) → Port 7710                    │  │
│  │  • github (10 tools) → NPX                               │  │
│  │  • memory (5 tools) → NPX                                 │  │
│  │  • sentry (5 tools) → NPX                                │  │
│  └───────────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────┐
│                    Docker Services (Local)                       │
│                                                                  │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐         │
│  │ MCP Server   │  │ PostgreSQL   │  │ Redis        │         │
│  │ :7710        │  │ :7173       │  │ :7174        │         │
│  └──────────────┘  └──────────────┘  └──────────────┘         │
│                                                                  │
│  ┌──────────────┐  ┌──────────────┐                           │
│  │ ChromaDB     │  │ Firecrawl    │                           │
│  │ :8000        │  │ :7172        │                           │
│  └──────────────┘  └──────────────┘                           │
└─────────────────────────────────────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────┐
│                    Remote (Pi5)                                  │
│                                                                  │
│  ┌──────────────┐                                               │
│  │ SearXNG      │                                               │
│  │ :7171        │                                               │
│  │ (Search API) │                                               │
│  └──────────────┘                                               │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│                    Before Optimization                           │
│                                                                  │
│  Tool Schemas: 90 tools × 150 tokens = 13,500 tokens           │
│  Web Fetch: ~8,000 tokens per page                             │
│  Tool Outputs: Full JSON in context                            │
│  Total: ~200,000 tokens per session                            │
└─────────────────────────────────────────────────────────────────┘

                              ↓

┌─────────────────────────────────────────────────────────────────┐
│                    After Optimization                            │
│                                                                  │
│  Tool Schemas: 64 tools × 42 tokens = 2,700 tokens (-80%)    │
│  Web Fetch: Quick fetch with token budget = ~300 tokens (-96%)│
│  Tool Outputs: External reference = ~50 tokens (-98%)            │
│  Total: ~30,000 tokens per session (-85%)                      │
└─────────────────────────────────────────────────────────────────┘

{
  "mcpServers": {
    "mcp-server": {
      "command": "docker",
      "args": ["exec", "-i", "mcp-server", "python", "-c", "from mcp_server.server import run; run()"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"]
    },
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-memory"]
    },
    "sentry": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sentry"]
    },
    "cloudflare": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-cloudflare"]
    }
  }
}

# 1. Clone
git clone https://github.com/simpletoolsindia/extra_skills_mcp_tools.git
cd extra_skills_mcp_tools

# 2. Run installer (follow prompts)
./install-claude-code.sh

# 3. Enter Pi5 IP when prompted (default: 192.168.0.2)
#    Or press Enter to skip (SearXNG will be unavailable)

# 4. Restart Claude Code
claude

# 5. Verify
docker compose -f docker-compose.local.yml ps

# Start Docker services
docker compose -f docker-compose.local.yml up -d

# Add to ~/.claude/settings.json
cat >> ~/.claude/settings.json << 'EOF'
{
  "mcpServers": {
    "mcp-server": {
      "command": "docker",
      "args": ["exec", "-i", "mcp-server", "python", "-c", "from mcp_server.server import run; run()"]
    }
  }
}
EOF

# Pi5 (Remote) SearXNG
export SEARXNG_BASE_URL=https://your-pi5-ip:7171

# Local Ollama (optional)
export OLLAMA_BASE_URL=http://localhost:11434

# PostgreSQL
export POSTGRES_HOST=localhost
export POSTGRES_PORT=7173
export POSTGRES_DB=mcp_server
export POSTGRES_USER=mcp_user
export POSTGRES_PASSWORD=postgres

# Redis
export REDIS_HOST=localhost
export REDIS_PORT=7174

# Claude Code Optimization
export MAX_THINKING_TOKENS=10000
export CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=50

# On Pi5
git clone https://github.com/simpletoolsindia/extra_skills_mcp_tools.git
cd extra_skills_mcp_tools
./start-remote.sh

# Start all services
docker compose -f docker-compose.local.yml up -d

# Stop all services
docker compose -f docker-compose.local.yml down

# View logs
docker compose -f docker-compose.local.yml logs -f mcp-server

# Rebuild after changes
docker compose -f docker-compose.local.yml up -d --build

# Quick restart
./start.sh    # Start
./stop.sh     # Stop

# Test token optimization
docker exec mcp-server python -c "
from src.mcp_server.server import _get_token_stats
import json
print(json.dumps(_get_token_stats(), indent=2))
"

# Test web search
docker exec mcp-server python -c "
from src.mcp_server.tools.searxng import search
print(search('MCP token optimization', limit=3))
"

# Test web fetch
docker exec mcp-server python -c "
from src.mcp_server.tools.web_fetch_optimized import quick_fetch
result = quick_fetch('https://example.com', max_tokens=500)
print(f'Title: {result[\"title\"]}')
print(f'Tokens: {result[\"tokens_used\"]}')
"

# Test MCP via network
echo '{"jsonrpc":"2.0","method":"tools/call","params":{"name":"get_token_stats","arguments":{}},"id":1}' | nc localhost 7710

# Ensure Pi5 SearXNG has limiter disabled
ssh pi5 "docker exec searxng sed -i 's/limiter: true/limiter: false/' /etc/searxng/settings.yml && docker restart searxng"

# Rebuild MCP server (includes ca-certificates)
docker compose -f docker-compose.local.yml up -d --build mcp-server

# Check and restart
docker compose restart chromadb