snipara-mcp 1.1.1__tar.gz

snipara_mcp-1.1.1/.gitignore

@@ -0,0 +1,44 @@
+# Dependencies
+node_modules
+.pnpm-store
+
+# Build outputs
+.next
+.turbo
+dist
+out
+
+# Environment
+.env
+.env.local
+.env.*.local
+.env.docker
+
+# IDE
+.idea
+.vscode
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+npm-debug.log*
+pnpm-debug.log*
+
+# Testing
+coverage
+
+# Database
+*.db
+*.sqlite
+
+# Python
+__pycache__
+*.pyc
+.venv
+.vercel
+.env*.local

snipara_mcp-1.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Snipara
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

snipara_mcp-1.1.1/PKG-INFO

@@ -0,0 +1,189 @@
+Metadata-Version: 2.3
+Name: snipara-mcp
+Version: 1.1.1
+Summary: MCP server for Snipara - Context optimization for LLMs
+Project-URL: Homepage, https://snipara.com
+Project-URL: Documentation, https://docs.snipara.com
+Project-URL: Repository, https://github.com/alopez3006/snipara-mcp-server
+Author-email: Snipara <support@snipara.com>
+License: MIT
+License-File: LICENSE
+Keywords: claude,context,cursor,documentation,llm,mcp,snipara
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.26.0
+Requires-Dist: mcp>=1.0.0
+Description-Content-Type: text/markdown
+
+# Snipara MCP Server
+
+[![PyPI version](https://badge.fury.io/py/snipara-mcp.svg)](https://pypi.org/project/snipara-mcp/)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+MCP server for [Snipara](https://snipara.com) - Context optimization for any LLM.
+
+Query your documentation efficiently with **90% token reduction**. Works with any MCP-compatible client including Claude Desktop, Cursor, Windsurf, Gemini, GPT, and more.
+
+**LLM-agnostic**: Snipara optimizes context delivery - you use your own LLM (Claude, GPT, Gemini, Llama, etc.).
+
+## Installation
+
+### Option 1: uvx (Recommended - No Install)
+
+```bash
+uvx snipara-mcp
+```
+
+### Option 2: pip
+
+```bash
+pip install snipara-mcp
+```
+
+## Configuration
+
+### Claude Desktop
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows):
+
+```json
+{
+  "mcpServers": {
+    "snipara": {
+      "command": "uvx",
+      "args": ["snipara-mcp"],
+      "env": {
+        "SNIPARA_API_KEY": "sk-your-api-key",
+        "SNIPARA_PROJECT_ID": "your-project-id"
+      }
+    }
+  }
+}
+```
+
+### Cursor
+
+Add to `~/.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "snipara": {
+      "command": "uvx",
+      "args": ["snipara-mcp"],
+      "env": {
+        "SNIPARA_API_KEY": "sk-your-api-key",
+        "SNIPARA_PROJECT_ID": "your-project-id"
+      }
+    }
+  }
+}
+```
+
+### Claude Code
+
+```bash
+claude mcp add snipara -- uvx snipara-mcp
+```
+
+Then set environment variables in your shell or `.env` file.
+
+### Windsurf
+
+Add to `~/.codeium/windsurf/mcp_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "snipara": {
+      "command": "uvx",
+      "args": ["snipara-mcp"],
+      "env": {
+        "SNIPARA_API_KEY": "sk-your-api-key",
+        "SNIPARA_PROJECT_ID": "your-project-id"
+      }
+    }
+  }
+}
+```
+
+## Environment Variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `SNIPARA_API_KEY` | Yes | Your Snipara API key |
+| `SNIPARA_PROJECT_ID` | Yes | Your project ID |
+| `SNIPARA_API_URL` | No | API URL (default: https://api.snipara.com) |
+
+Get your API key and project ID from [snipara.com/dashboard](https://snipara.com/dashboard).
+
+## Available Tools
+
+### Primary Tool
+
+- **`rlm_context_query`** - Query optimized context from your documentation
+  - `query`: Your question (required)
+  - `max_tokens`: Token budget (default: 4000)
+  - `search_mode`: `keyword`, `semantic`, or `hybrid` (default: hybrid)
+
+### Search & Navigation
+
+- **`rlm_search`** - Regex pattern search
+- **`rlm_sections`** - List all document sections
+- **`rlm_read`** - Read specific line ranges
+- **`rlm_stats`** - Documentation statistics
+
+### Advanced (Pro+)
+
+- **`rlm_decompose`** - Break complex queries into sub-queries
+- **`rlm_multi_query`** - Execute multiple queries with shared token budget
+
+### Session Context
+
+- **`rlm_inject`** - Set context for subsequent queries
+- **`rlm_context`** - Show current context
+- **`rlm_clear_context`** - Clear context
+
+## Example Usage
+
+Once configured, ask your LLM:
+
+> "Use snipara to find how authentication works in my codebase"
+
+The LLM will call `rlm_context_query` and return relevant documentation sections.
+
+## Alternative: Direct HTTP (No Local Install)
+
+For clients that support HTTP transport (Claude Code, Cursor v0.48+), you can connect directly without installing anything:
+
+**Claude Code:**
+```json
+{
+  "mcpServers": {
+    "snipara": {
+      "type": "http",
+      "url": "https://api.snipara.com/mcp/YOUR_PROJECT_ID",
+      "headers": {
+        "Authorization": "Bearer sk-your-api-key"
+      }
+    }
+  }
+}
+```
+
+## Support
+
+- Website: [snipara.com](https://snipara.com)
+- Issues: [github.com/alopez3006/snipara-mcp/issues](https://github.com/alopez3006/snipara-mcp/issues)
+- Email: support@snipara.com
+
+## License
+
+MIT

snipara_mcp-1.1.1/README.md

@@ -0,0 +1,166 @@
+# Snipara MCP Server
+
+[![PyPI version](https://badge.fury.io/py/snipara-mcp.svg)](https://pypi.org/project/snipara-mcp/)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+MCP server for [Snipara](https://snipara.com) - Context optimization for any LLM.
+
+Query your documentation efficiently with **90% token reduction**. Works with any MCP-compatible client including Claude Desktop, Cursor, Windsurf, Gemini, GPT, and more.
+
+**LLM-agnostic**: Snipara optimizes context delivery - you use your own LLM (Claude, GPT, Gemini, Llama, etc.).
+
+## Installation
+
+### Option 1: uvx (Recommended - No Install)
+
+```bash
+uvx snipara-mcp
+```
+
+### Option 2: pip
+
+```bash
+pip install snipara-mcp
+```
+
+## Configuration
+
+### Claude Desktop
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows):
+
+```json
+{
+  "mcpServers": {
+    "snipara": {
+      "command": "uvx",
+      "args": ["snipara-mcp"],
+      "env": {
+        "SNIPARA_API_KEY": "sk-your-api-key",
+        "SNIPARA_PROJECT_ID": "your-project-id"
+      }
+    }
+  }
+}
+```
+
+### Cursor
+
+Add to `~/.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "snipara": {
+      "command": "uvx",
+      "args": ["snipara-mcp"],
+      "env": {
+        "SNIPARA_API_KEY": "sk-your-api-key",
+        "SNIPARA_PROJECT_ID": "your-project-id"
+      }
+    }
+  }
+}
+```
+
+### Claude Code
+
+```bash
+claude mcp add snipara -- uvx snipara-mcp
+```
+
+Then set environment variables in your shell or `.env` file.
+
+### Windsurf
+
+Add to `~/.codeium/windsurf/mcp_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "snipara": {
+      "command": "uvx",
+      "args": ["snipara-mcp"],
+      "env": {
+        "SNIPARA_API_KEY": "sk-your-api-key",
+        "SNIPARA_PROJECT_ID": "your-project-id"
+      }
+    }
+  }
+}
+```
+
+## Environment Variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `SNIPARA_API_KEY` | Yes | Your Snipara API key |
+| `SNIPARA_PROJECT_ID` | Yes | Your project ID |
+| `SNIPARA_API_URL` | No | API URL (default: https://api.snipara.com) |
+
+Get your API key and project ID from [snipara.com/dashboard](https://snipara.com/dashboard).
+
+## Available Tools
+
+### Primary Tool
+
+- **`rlm_context_query`** - Query optimized context from your documentation
+  - `query`: Your question (required)
+  - `max_tokens`: Token budget (default: 4000)
+  - `search_mode`: `keyword`, `semantic`, or `hybrid` (default: hybrid)
+
+### Search & Navigation
+
+- **`rlm_search`** - Regex pattern search
+- **`rlm_sections`** - List all document sections
+- **`rlm_read`** - Read specific line ranges
+- **`rlm_stats`** - Documentation statistics
+
+### Advanced (Pro+)
+
+- **`rlm_decompose`** - Break complex queries into sub-queries
+- **`rlm_multi_query`** - Execute multiple queries with shared token budget
+
+### Session Context
+
+- **`rlm_inject`** - Set context for subsequent queries
+- **`rlm_context`** - Show current context
+- **`rlm_clear_context`** - Clear context
+
+## Example Usage
+
+Once configured, ask your LLM:
+
+> "Use snipara to find how authentication works in my codebase"
+
+The LLM will call `rlm_context_query` and return relevant documentation sections.
+
+## Alternative: Direct HTTP (No Local Install)
+
+For clients that support HTTP transport (Claude Code, Cursor v0.48+), you can connect directly without installing anything:
+
+**Claude Code:**
+```json
+{
+  "mcpServers": {
+    "snipara": {
+      "type": "http",
+      "url": "https://api.snipara.com/mcp/YOUR_PROJECT_ID",
+      "headers": {
+        "Authorization": "Bearer sk-your-api-key"
+      }
+    }
+  }
+}
+```
+
+## Support
+
+- Website: [snipara.com](https://snipara.com)
+- Issues: [github.com/alopez3006/snipara-mcp/issues](https://github.com/alopez3006/snipara-mcp/issues)
+- Email: support@snipara.com
+
+## License
+
+MIT

snipara_mcp-1.1.1/pyproject.toml

@@ -0,0 +1,45 @@
+[project]
+name = "snipara-mcp"
+version = "1.1.1"
+description = "MCP server for Snipara - Context optimization for LLMs"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Snipara", email = "support@snipara.com" }]
+keywords = ["mcp", "llm", "context", "documentation", "snipara", "claude", "cursor"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+dependencies = [
+    "mcp>=1.0.0",
+    "httpx>=0.26.0",
+]
+
+[project.scripts]
+snipara-mcp = "snipara_mcp:main"
+
+[project.urls]
+Homepage = "https://snipara.com"
+Documentation = "https://docs.snipara.com"
+Repository = "https://github.com/alopez3006/snipara-mcp-server"
+
+[build-system]
+requires = ["hatchling<1.26"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/snipara_mcp"]
+
+[tool.hatch.metadata]
+license-files = []
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"

snipara_mcp-1.1.1/src/snipara_mcp/__init__.py

@@ -0,0 +1,6 @@
+"""Snipara MCP Server - Context optimization for LLMs."""
+
+from .server import main
+
+__version__ = "1.1.1"
+__all__ = ["main"]

snipara_mcp-1.1.1/src/snipara_mcp/server.py

@@ -0,0 +1,438 @@
+#!/usr/bin/env python3
+"""
+Snipara MCP Server - stdio transport to Snipara REST API.
+
+This MCP server connects your LLM client (Claude Desktop, Cursor, etc.)
+to your Snipara project for context-optimized documentation queries.
+
+Usage:
+    snipara-mcp
+
+Environment variables:
+    SNIPARA_API_KEY: Your Snipara API key (required)
+    SNIPARA_PROJECT_ID: Your project ID (required)
+    SNIPARA_API_URL: API URL (default: https://api.snipara.com)
+"""
+
+import asyncio
+import os
+import sys
+import time
+from typing import Any
+
+import httpx
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+from mcp.types import TextContent, Tool
+
+# Configuration
+API_URL = os.environ.get("SNIPARA_API_URL", "https://api.snipara.com")
+API_KEY = os.environ.get("SNIPARA_API_KEY", "")
+PROJECT_ID = os.environ.get("SNIPARA_PROJECT_ID", "")
+
+# Session context cache
+_session_context: str = ""
+
+# Settings cache (5 minute TTL)
+_settings_cache: dict[str, Any] = {}
+_settings_cache_time: float = 0
+SETTINGS_CACHE_TTL = 300  # 5 minutes
+
+
+async def get_project_settings() -> dict[str, Any]:
+    """Fetch project automation settings from API with caching."""
+    global _settings_cache, _settings_cache_time
+
+    # Return cached settings if still valid
+    if _settings_cache and (time.time() - _settings_cache_time) < SETTINGS_CACHE_TTL:
+        return _settings_cache
+
+    # Fetch fresh settings from API
+    try:
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            response = await client.get(
+                f"{API_URL}/v1/{PROJECT_ID}/automation",
+                headers=get_headers(),
+            )
+            if response.status_code == 200:
+                data = response.json()
+                _settings_cache = data.get("settings", {})
+                _settings_cache_time = time.time()
+                return _settings_cache
+    except Exception:
+        pass  # Fall back to defaults on error
+
+    # Return defaults if API fails
+    return {
+        "maxTokensPerQuery": 4000,
+        "searchMode": "hybrid",
+        "includeSummaries": True,
+        "autoInjectContext": False,
+        "enrichPrompts": False,
+    }
+
+server = Server("snipara")
+
+
+def get_headers() -> dict[str, str]:
+    return {"X-API-Key": API_KEY, "Content-Type": "application/json"}
+
+
+async def call_api(tool: str, params: dict[str, Any]) -> dict[str, Any]:
+    """Call the Snipara MCP API."""
+    async with httpx.AsyncClient(timeout=60.0) as client:
+        response = await client.post(
+            f"{API_URL}/v1/{PROJECT_ID}/mcp",
+            headers=get_headers(),
+            json={"tool": tool, "params": params},
+        )
+        response.raise_for_status()
+        return response.json()
+
+
+@server.list_tools()
+async def list_tools() -> list[Tool]:
+    """List available Snipara tools."""
+    return [
+        Tool(
+            name="rlm_context_query",
+            description="""Query optimized context from your documentation.
+
+Returns ranked, relevant sections that fit within your token budget.
+This is the PRIMARY tool - use it for any documentation questions.
+
+Examples:
+- "How does authentication work?"
+- "What are the API endpoints?"
+- "Where is the database schema?"
+
+Returns sections with relevance scores, file paths, and line numbers.""",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "query": {"type": "string", "description": "Your question"},
+                    "max_tokens": {"type": "integer", "default": 4000, "description": "Token budget"},
+                    "search_mode": {"type": "string", "enum": ["keyword", "semantic", "hybrid"], "default": "hybrid"},
+                },
+                "required": ["query"],
+            },
+        ),
+        Tool(
+            name="rlm_ask",
+            description="Query documentation (basic). Use rlm_context_query for better results.",
+            inputSchema={
+                "type": "object",
+                "properties": {"question": {"type": "string", "description": "The question to ask"}},
+                "required": ["question"],
+            },
+        ),
+        Tool(
+            name="rlm_search",
+            description="Search documentation for a pattern (regex supported).",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "pattern": {"type": "string", "description": "Regex pattern"},
+                    "max_results": {"type": "integer", "default": 20},
+                },
+                "required": ["pattern"],
+            },
+        ),
+        Tool(
+            name="rlm_decompose",
+            description="Break complex query into sub-queries with execution order.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "query": {"type": "string", "description": "Complex question to decompose"},
+                    "max_depth": {"type": "integer", "default": 2},
+                },
+                "required": ["query"],
+            },
+        ),
+        Tool(
+            name="rlm_multi_query",
+            description="Execute multiple queries in one call with shared token budget.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "queries": {
+                        "type": "array",
+                        "items": {"type": "object", "properties": {"query": {"type": "string"}}, "required": ["query"]},
+                    },
+                    "max_tokens": {"type": "integer", "default": 8000},
+                },
+                "required": ["queries"],
+            },
+        ),
+        Tool(
+            name="rlm_inject",
+            description="Set session context for subsequent queries.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "context": {"type": "string", "description": "Context to inject"},
+                    "append": {"type": "boolean", "default": False},
+                },
+                "required": ["context"],
+            },
+        ),
+        Tool(
+            name="rlm_context",
+            description="Show current session context.",
+            inputSchema={"type": "object", "properties": {}, "required": []},
+        ),
+        Tool(
+            name="rlm_clear_context",
+            description="Clear session context.",
+            inputSchema={"type": "object", "properties": {}, "required": []},
+        ),
+        Tool(
+            name="rlm_stats",
+            description="Show documentation statistics.",
+            inputSchema={"type": "object", "properties": {}, "required": []},
+        ),
+        Tool(
+            name="rlm_sections",
+            description="List all document sections.",
+            inputSchema={"type": "object", "properties": {}, "required": []},
+        ),
+        Tool(
+            name="rlm_read",
+            description="Read specific lines from documentation.",
+            inputSchema={
+                "type": "object",
+                "properties": {"start_line": {"type": "integer"}, "end_line": {"type": "integer"}},
+                "required": ["start_line", "end_line"],
+            },
+        ),
+        Tool(
+            name="rlm_settings",
+            description="Show current project settings from dashboard (max_tokens, search_mode, etc.).",
+            inputSchema={"type": "object", "properties": {"refresh": {"type": "boolean", "default": False, "description": "Force refresh from API"}}, "required": []},
+        ),
+    ]
+
+
+@server.call_tool()
+async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
+    """Handle tool calls."""
+    global _session_context
+
+    try:
+        if name == "rlm_context_query":
+            # Get project settings from dashboard (cached)
+            settings = await get_project_settings()
+
+            query = arguments["query"]
+            if _session_context:
+                query = f"Context: {_session_context}\n\nQuestion: {query}"
+
+            # Use settings from dashboard, allow override from arguments
+            max_tokens = arguments.get("max_tokens") or settings.get("maxTokensPerQuery", 4000)
+            search_mode = arguments.get("search_mode") or settings.get("searchMode", "hybrid")
+            include_summaries = settings.get("includeSummaries", True)
+
+            result = await call_api("rlm_context_query", {
+                "query": query,
+                "max_tokens": max_tokens,
+                "search_mode": search_mode,
+                "include_metadata": True,
+                "prefer_summaries": include_summaries,
+            })
+
+            if result.get("success"):
+                data = result.get("result", {})
+                sections = data.get("sections", [])
+                if sections:
+                    parts = ["## Relevant Documentation\n"]
+                    for s in sections:
+                        parts.append(f"### {s.get('title', 'Untitled')}")
+                        parts.append(f"*{s.get('file', '')} | Score: {s.get('relevance_score', 0):.2f}*\n")
+                        parts.append(s.get("content", ""))
+                        parts.append("")
+                    parts.append(f"---\n*{len(sections)} sections, {data.get('total_tokens', 0)} tokens*")
+                    return [TextContent(type="text", text="\n".join(parts))]
+                return [TextContent(type="text", text="No relevant documentation found.")]
+            return [TextContent(type="text", text=f"**Error:** {result.get('error', 'Unknown error')}")]
+
+        elif name == "rlm_ask":
+            question = arguments["question"]
+            if _session_context:
+                question = f"Context: {_session_context}\n\nQuestion: {question}"
+
+            result = await call_api("rlm_context_query", {
+                "query": question, "max_tokens": 4000, "search_mode": "hybrid", "include_metadata": True,
+            })
+
+            if result.get("success"):
+                data = result.get("result", {})
+                sections = data.get("sections", [])
+                if sections:
+                    parts = ["## Relevant Documentation\n"]
+                    for s in sections:
+                        parts.append(f"### {s.get('title', 'Untitled')}")
+                        parts.append(f"*{s.get('file', '')}*\n")
+                        parts.append(s.get("content", ""))
+                        parts.append("")
+                    return [TextContent(type="text", text="\n".join(parts))]
+                return [TextContent(type="text", text="No relevant documentation found.")]
+            return [TextContent(type="text", text=f"**Error:** {result.get('error', 'Unknown error')}")]
+
+        elif name == "rlm_search":
+            result = await call_api("rlm_search", {"pattern": arguments["pattern"]})
+            if result.get("success"):
+                matches = result.get("result", {}).get("matches", [])
+                max_results = arguments.get("max_results", 20)
+                if matches:
+                    lines = [f"Found {len(matches)} matches:\n"]
+                    for m in matches[:max_results]:
+                        lines.append(f"  {m.get('file', '')}:{m.get('line_number', 0)}: {m.get('content', '')[:100]}")
+                    if len(matches) > max_results:
+                        lines.append(f"\n... and {len(matches) - max_results} more")
+                    return [TextContent(type="text", text="\n".join(lines))]
+                return [TextContent(type="text", text=f"No matches for '{arguments['pattern']}'")]
+            return [TextContent(type="text", text=f"**Error:** {result.get('error', 'Unknown error')}")]
+
+        elif name == "rlm_decompose":
+            result = await call_api("rlm_decompose", {"query": arguments["query"], "max_depth": arguments.get("max_depth", 2)})
+            if result.get("success"):
+                data = result.get("result", {})
+                sub = data.get("sub_queries", [])
+                lines = [f"**Decomposed into {len(sub)} sub-queries:**\n"]
+                for q in sub:
+                    lines.append(f"{q.get('id', 0)}. {q.get('query', '')} (priority: {q.get('priority', 1)})")
+                lines.append(f"\n**Suggested order:** {data.get('suggested_sequence', [])}")
+                return [TextContent(type="text", text="\n".join(lines))]
+            return [TextContent(type="text", text=f"**Error:** {result.get('error', 'Unknown error')}")]
+
+        elif name == "rlm_multi_query":
+            result = await call_api("rlm_multi_query", {
+                "queries": arguments["queries"], "max_tokens": arguments.get("max_tokens", 8000),
+            })
+            if result.get("success"):
+                data = result.get("result", {})
+                parts = [f"**Executed {data.get('queries_executed', 0)} queries:**\n"]
+                for r in data.get("results", []):
+                    parts.append(f"### {r.get('query', '')}")
+                    for s in r.get("sections", [])[:2]:
+                        parts.append(f"- {s.get('title', '')} ({s.get('file', '')})")
+                    parts.append("")
+                parts.append(f"*Total: {data.get('total_tokens', 0)} tokens*")
+                return [TextContent(type="text", text="\n".join(parts))]
+            return [TextContent(type="text", text=f"**Error:** {result.get('error', 'Unknown error')}")]
+
+        elif name == "rlm_inject":
+            ctx = arguments["context"]
+            if arguments.get("append") and _session_context:
+                _session_context = _session_context + "\n\n" + ctx
+            else:
+                _session_context = ctx
+            try:
+                await call_api("rlm_inject", {"context": _session_context})
+            except Exception:
+                pass
+            return [TextContent(type="text", text=f"Session context {'appended' if arguments.get('append') else 'set'} ({len(_session_context)} chars)")]
+
+        elif name == "rlm_context":
+            if _session_context:
+                return [TextContent(type="text", text=f"**Session Context:**\n\n{_session_context}")]
+            return [TextContent(type="text", text="No session context. Use rlm_inject to set.")]
+
+        elif name == "rlm_clear_context":
+            if _session_context:
+                _session_context = ""
+                try:
+                    await call_api("rlm_clear_context", {})
+                except Exception:
+                    pass
+                return [TextContent(type="text", text="Session context cleared.")]
+            return [TextContent(type="text", text="No context to clear.")]
+
+        elif name == "rlm_stats":
+            result = await call_api("rlm_stats", {})
+            if result.get("success"):
+                # Handle both "result" and "data" keys from different API responses
+                d = result.get("result", result.get("data", {}))
+                # Backend returns total_characters, not total_tokens
+                files_loaded = d.get('files_loaded', d.get('document_count', 0))
+                total_lines = d.get('total_lines', 0)
+                total_chars = d.get('total_characters', 0)
+                sections = d.get('sections', d.get('chunk_count', 0))
+                # Safe formatting - convert to int if numeric string, else show as-is
+                def fmt(v):
+                    if isinstance(v, (int, float)):
+                        return f"{int(v):,}"
+                    if isinstance(v, str) and v.isdigit():
+                        return f"{int(v):,}"
+                    return str(v) if v else "0"
+                return [TextContent(type="text", text=f"**Stats:**\n- Files: {fmt(files_loaded)}\n- Lines: {fmt(total_lines)}\n- Characters: {fmt(total_chars)}\n- Sections: {fmt(sections)}")]
+            return [TextContent(type="text", text=f"**Error:** {result.get('error', 'Unknown error')}")]
+
+        elif name == "rlm_sections":
+            result = await call_api("rlm_sections", {})
+            if result.get("success"):
+                sections = result.get("result", {}).get("sections", [])
+                lines = ["**Documents:**\n"]
+                for s in sections:
+                    lines.append(f"- {s.get('path', '')} ({s.get('chunk_count', 0)} chunks)")
+                return [TextContent(type="text", text="\n".join(lines))]
+            return [TextContent(type="text", text=f"**Error:** {result.get('error', 'Unknown error')}")]
+
+        elif name == "rlm_read":
+            result = await call_api("rlm_read", {"start_line": arguments["start_line"], "end_line": arguments["end_line"]})
+            if result.get("success"):
+                content = result.get("result", {}).get("content", "")
+                return [TextContent(type="text", text=f"**Lines {arguments['start_line']}-{arguments['end_line']}:**\n```\n{content}\n```")]
+            return [TextContent(type="text", text=f"**Error:** {result.get('error', 'Unknown error')}")]
+
+        elif name == "rlm_settings":
+            global _settings_cache, _settings_cache_time
+            # Force refresh if requested
+            if arguments.get("refresh"):
+                _settings_cache = {}
+                _settings_cache_time = 0
+            settings = await get_project_settings()
+            cache_age = int(time.time() - _settings_cache_time) if _settings_cache_time else 0
+            lines = [
+                "**Project Settings** (from dashboard)\n",
+                f"- Max Tokens: {settings.get('maxTokensPerQuery', 4000)}",
+                f"- Search Mode: {settings.get('searchMode', 'hybrid')}",
+                f"- Include Summaries: {settings.get('includeSummaries', True)}",
+                f"- Auto-Inject Context: {settings.get('autoInjectContext', False)}",
+                f"- Enrich Prompts: {settings.get('enrichPrompts', False)}",
+                f"\n*Cache age: {cache_age}s (TTL: {SETTINGS_CACHE_TTL}s)*",
+            ]
+            return [TextContent(type="text", text="\n".join(lines))]
+
+        else:
+            return [TextContent(type="text", text=f"Unknown tool: {name}")]
+
+    except httpx.HTTPStatusError as e:
+        return [TextContent(type="text", text=f"**API Error:** {e.response.status_code} - {e.response.text}")]
+    except httpx.ConnectError:
+        return [TextContent(type="text", text=f"**Connection Error:** Cannot reach {API_URL}")]
+    except Exception as e:
+        return [TextContent(type="text", text=f"**Error:** {type(e).__name__}: {str(e)}")]
+
+
+async def run_server():
+    """Run the MCP server."""
+    if not API_KEY:
+        print("Error: SNIPARA_API_KEY environment variable required", file=sys.stderr)
+        sys.exit(1)
+    if not PROJECT_ID:
+        print("Error: SNIPARA_PROJECT_ID environment variable required", file=sys.stderr)
+        sys.exit(1)
+
+    async with stdio_server() as (read_stream, write_stream):
+        await server.run(read_stream, write_stream, server.create_initialization_options())
+
+
+def main():
+    """Entry point for snipara-mcp command."""
+    asyncio.run(run_server())
+
+
+if __name__ == "__main__":
+    main()