Convert to proper MCP server with SSE transport for HTTP access

app.py

@@ -1,35 +1,33 @@
-import json
-import os
-from typing import List, Dict, Any, Optional
-from fastapi import FastAPI, HTTPException
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
-
-app = FastAPI(title="MCP Documentation Server", version="1.0.0")
+#!/usr/bin/env python3
+"""
+MCP Server for MCP Documentation
+Hosted on Hugging Face Spaces with HTTP transport
+"""
 
-# Add CORS middleware
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
+import json
+import asyncio
+import logging
+from typing import Any, Dict, List, Optional
+from mcp.server import Server
+from mcp.server.models import InitializationOptions
+from mcp.server.sse import sse_server
+from mcp.types import (
+    Resource,
+    Tool,
+    TextContent,
+    LoggingLevel
 )
 
-# Global variables for loaded data
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Global data storage
 chunks_data = None
 docs_data = None
 
-class SearchRequest(BaseModel):
-    query: str
-    limit: int = 5
-
-class SearchResponse(BaseModel):
-    results: List[Dict[str, Any]]
-    total: int
-
 def load_data():
-    """Load the embedded chunks data"""
+    """Load the documentation chunks and metadata"""
     global chunks_data, docs_data
     
     try:
@@ -41,48 +39,122 @@ def load_data():
         with open('mcp_docs/index/docs_md.json', 'r', encoding='utf-8') as f:
             docs_data = json.load(f)
         
-        print(f"Loaded {len(chunks_data)} chunks and {len(docs_data)} documents")
-        print("Using text-based search (no FAISS index required)")
+        logger.info(f"Loaded {len(chunks_data)} chunks and {len(docs_data)} documents")
         
     except Exception as e:
-        print(f"Error loading data: {e}")
+        logger.error(f"Error loading data: {e}")
         raise
 
-@app.on_event("startup")
-async def startup_event():
-    """Load data on startup"""
-    load_data()
+# Initialize the MCP server
+server = Server("mcp-docs-server")
 
-@app.get("/")
-async def root():
-    """Health check endpoint"""
-    return {
-        "message": "MCP Documentation Server",
-        "status": "running",
-        "chunks_loaded": len(chunks_data) if chunks_data else 0,
-        "docs_loaded": len(docs_data) if docs_data else 0
-    }
+@server.list_resources()
+async def list_resources() -> List[Resource]:
+    """List available documentation resources"""
+    if not docs_data:
+        return []
+    
+    resources = []
+    for doc in docs_data:
+        resources.append(Resource(
+            uri=f"mcp://docs/{doc.get('id', 'unknown')}",
+            name=doc.get('title', 'Untitled'),
+            description=doc.get('content', '')[:200] + "..." if len(doc.get('content', '')) > 200 else doc.get('content', ''),
+            mimeType="text/plain"
+        ))
+    
+    return resources
 
-@app.post("/search", response_model=SearchResponse)
-async def search_docs(request: SearchRequest):
-    """Search through documentation chunks using text matching"""
+@server.read_resource()
+async def read_resource(uri: str) -> str:
+    """Read a specific documentation resource"""
     if not chunks_data:
-        raise HTTPException(status_code=500, detail="Data not loaded")
+        return "Data not loaded"
     
-    try:
-        query_lower = request.query.lower()
-        results = []
+    # Extract document ID from URI
+    if uri.startswith("mcp://docs/"):
+        doc_id = uri.replace("mcp://docs/", "")
+        
+        # Find chunks for this document
+        doc_chunks = [chunk for chunk in chunks_data if chunk.get('doc_id') == doc_id]
+        
+        if doc_chunks:
+            # Combine all chunks for the document
+            content = "\n\n".join([chunk.get('text', '') for chunk in doc_chunks])
+            return content
+        else:
+            return f"Document {doc_id} not found"
+    
+    return "Invalid URI"
+
+@server.list_tools()
+async def list_tools() -> List[Tool]:
+    """List available tools"""
+    return [
+        Tool(
+            name="search_docs",
+            description="Search through MCP documentation chunks",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "Search query"
+                    },
+                    "limit": {
+                        "type": "integer",
+                        "description": "Maximum number of results",
+                        "default": 5
+                    }
+                },
+                "required": ["query"]
+            }
+        ),
+        Tool(
+            name="get_chunk",
+            description="Get a specific documentation chunk by ID",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "chunk_id": {
+                        "type": "string",
+                        "description": "Chunk ID to retrieve"
+                    }
+                },
+                "required": ["chunk_id"]
+            }
+        ),
+        Tool(
+            name="list_docs",
+            description="List all available documents",
+            inputSchema={
+                "type": "object",
+                "properties": {}
+            }
+        )
+    ]
+
+@server.call_tool()
+async def call_tool(name: str, arguments: Dict[str, Any]) -> List[TextContent]:
+    """Handle tool calls"""
+    if not chunks_data:
+        return [TextContent(type="text", text="Data not loaded")]
+    
+    if name == "search_docs":
+        query = arguments.get("query", "").lower()
+        limit = arguments.get("limit", 5)
         
+        results = []
         for chunk in chunks_data:
             text = chunk.get('text', '').lower()
             title = chunk.get('title', '').lower()
             
-            # Simple scoring based on query matches
+            # Simple scoring
             score = 0
-            if query_lower in text:
-                score += text.count(query_lower) * 2  # Text matches worth more
-            if query_lower in title:
-                score += title.count(query_lower) * 5  # Title matches worth most
+            if query in text:
+                score += text.count(query) * 2
+            if query in title:
+                score += title.count(query) * 5
             
             if score > 0:
                 results.append({
@@ -91,42 +163,70 @@ async def search_docs(request: SearchRequest):
                     "text": chunk.get('text'),
                     "url": chunk.get('url'),
                     "filename": chunk.get('filename'),
-                    "chunk_index": chunk.get('chunk_index'),
-                    "total_chunks": chunk.get('total_chunks'),
                     "score": score
                 })
         
-        # Sort by relevance score
-        results = sorted(results, key=lambda x: x['score'], reverse=True)
+        # Sort by score and limit results
+        results = sorted(results, key=lambda x: x['score'], reverse=True)[:limit]
         
-        return SearchResponse(
-            results=results[:request.limit],
-            total=len(results)
-        )
+        if results:
+            response = f"Found {len(results)} results for '{arguments.get('query', '')}':\n\n"
+            for i, result in enumerate(results, 1):
+                response += f"{i}. **{result['title']}** (Score: {result['score']})\n"
+                response += f"   {result['text'][:200]}...\n"
+                response += f"   Source: {result['filename']}\n\n"
+        else:
+            response = f"No results found for '{arguments.get('query', '')}'"
         
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Search error: {str(e)}")
-
-@app.get("/chunks/{chunk_id}")
-async def get_chunk(chunk_id: str):
-    """Get a specific chunk by ID"""
-    if not chunks_data:
-        raise HTTPException(status_code=500, detail="Data not loaded")
+        return [TextContent(type="text", text=response)]
     
-    for chunk in chunks_data:
-        if chunk.get('chunk_id') == chunk_id:
-            return chunk
+    elif name == "get_chunk":
+        chunk_id = arguments.get("chunk_id", "")
+        
+        for chunk in chunks_data:
+            if chunk.get('chunk_id') == chunk_id:
+                response = f"**{chunk.get('title', 'Untitled')}**\n\n"
+                response += f"{chunk.get('text', '')}\n\n"
+                response += f"Source: {chunk.get('filename', 'Unknown')}\n"
+                response += f"URL: {chunk.get('url', 'N/A')}"
+                return [TextContent(type="text", text=response)]
+        
+        return [TextContent(type="text", text=f"Chunk {chunk_id} not found")]
+    
+    elif name == "list_docs":
+        if not docs_data:
+            return [TextContent(type="text", text="No documents available")]
+        
+        response = "Available documents:\n\n"
+        for doc in docs_data:
+            response += f"- **{doc.get('title', 'Untitled')}**\n"
+            response += f"  ID: {doc.get('id', 'Unknown')}\n"
+            response += f"  URL: {doc.get('url', 'N/A')}\n\n"
+        
+        return [TextContent(type="text", text=response)]
     
-    raise HTTPException(status_code=404, detail="Chunk not found")
+    else:
+        return [TextContent(type="text", text=f"Unknown tool: {name}")]
 
-@app.get("/docs")
-async def list_docs():
-    """List all available documents"""
-    if not docs_data:
-        raise HTTPException(status_code=500, detail="Data not loaded")
+async def main():
+    """Main entry point"""
+    # Load data
+    load_data()
     
-    return {"documents": docs_data}
+    # Run the server with SSE transport for HTTP access
+    async with sse_server() as (read_stream, write_stream):
+        await server.run(
+            read_stream,
+            write_stream,
+            InitializationOptions(
+                server_name="mcp-docs-server",
+                server_version="1.0.0",
+                capabilities=server.get_capabilities(
+                    notification_options=None,
+                    experimental_capabilities=None
+                )
+            )
+        )
 
 if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    asyncio.run(main())

cursor_config.json

@@ -0,0 +1,9 @@
+{
+  "mcpServers": {
+    "mcp-docs-client": {
+      "command": "python",
+      "args": ["mcp_client_server.py"],
+      "cwd": "C:\\crawl\\mcp-docs-hf-space\\mcp-docs-server"
+    }
+  }
+}

mcp_client_server.py

@@ -0,0 +1,279 @@
+#!/usr/bin/env python3
+"""
+MCP Client Server that connects to Hugging Face Spaces API
+This acts as a bridge between Cursor and your Hugging Face Spaces server
+"""
+
+import json
+import asyncio
+import logging
+import aiohttp
+from typing import Any, Dict, List, Optional
+from mcp.server import Server
+from mcp.server.models import InitializationOptions
+from mcp.server.stdio import stdio_server
+from mcp.types import (
+    Resource,
+    Tool,
+    TextContent,
+    LoggingLevel
+)
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Hugging Face Spaces URL - replace with your actual space URL
+HF_SPACE_URL = "https://galcan-mcp-docs-server.hf.space"
+
+# Initialize the MCP server
+server = Server("mcp-docs-client")
+
+async def make_request(endpoint: str, method: str = "GET", data: dict = None) -> dict:
+    """Make HTTP request to Hugging Face Spaces API"""
+    url = f"{HF_SPACE_URL}{endpoint}"
+    
+    try:
+        async with aiohttp.ClientSession() as session:
+            if method == "GET":
+                async with session.get(url) as response:
+                    return await response.json()
+            elif method == "POST":
+                async with session.post(url, json=data) as response:
+                    return await response.json()
+    except Exception as e:
+        logger.error(f"Request failed: {e}")
+        return {"error": str(e)}
+
+@server.list_resources()
+async def list_resources() -> List[Resource]:
+    """List available documentation resources"""
+    try:
+        # Get docs from HF Spaces
+        response = await make_request("/docs")
+        if "error" in response:
+            return []
+        
+        resources = []
+        for doc in response.get("documents", []):
+            resources.append(Resource(
+                uri=f"mcp://docs/{doc.get('id', 'unknown')}",
+                name=doc.get('title', 'Untitled'),
+                description=doc.get('content', '')[:200] + "..." if len(doc.get('content', '')) > 200 else doc.get('content', ''),
+                mimeType="text/plain"
+            ))
+        
+        return resources
+    except Exception as e:
+        logger.error(f"Error listing resources: {e}")
+        return []
+
+@server.read_resource()
+async def read_resource(uri: str) -> str:
+    """Read a specific documentation resource"""
+    try:
+        # Extract document ID from URI
+        if uri.startswith("mcp://docs/"):
+            doc_id = uri.replace("mcp://docs/", "")
+            
+            # Search for chunks related to this document
+            search_response = await make_request("/search", "POST", {
+                "query": doc_id,
+                "limit": 10
+            })
+            
+            if "error" in search_response:
+                return f"Error: {search_response['error']}"
+            
+            results = search_response.get("results", [])
+            if results:
+                content = "\n\n".join([result.get("text", "") for result in results])
+                return content
+            else:
+                return f"Document {doc_id} not found"
+        
+        return "Invalid URI"
+    except Exception as e:
+        return f"Error reading resource: {e}"
+
+@server.list_tools()
+async def list_tools() -> List[Tool]:
+    """List available tools"""
+    return [
+        Tool(
+            name="search_docs",
+            description="Search through MCP documentation chunks on Hugging Face Spaces",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "Search query for MCP documentation"
+                    },
+                    "limit": {
+                        "type": "integer",
+                        "description": "Maximum number of results",
+                        "default": 5
+                    }
+                },
+                "required": ["query"]
+            }
+        ),
+        Tool(
+            name="get_chunk",
+            description="Get a specific documentation chunk by ID from Hugging Face Spaces",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "chunk_id": {
+                        "type": "string",
+                        "description": "Chunk ID to retrieve"
+                    }
+                },
+                "required": ["chunk_id"]
+            }
+        ),
+        Tool(
+            name="list_docs",
+            description="List all available documents from Hugging Face Spaces",
+            inputSchema={
+                "type": "object",
+                "properties": {}
+            }
+        ),
+        Tool(
+            name="health_check",
+            description="Check if the Hugging Face Spaces server is running",
+            inputSchema={
+                "type": "object",
+                "properties": {}
+            }
+        )
+    ]
+
+@server.call_tool()
+async def call_tool(name: str, arguments: Dict[str, Any]) -> List[TextContent]:
+    """Handle tool calls by forwarding to Hugging Face Spaces"""
+    
+    if name == "search_docs":
+        query = arguments.get("query", "")
+        limit = arguments.get("limit", 5)
+        
+        try:
+            response = await make_request("/search", "POST", {
+                "query": query,
+                "limit": limit
+            })
+            
+            if "error" in response:
+                return [TextContent(type="text", text=f"Error: {response['error']}")]
+            
+            results = response.get("results", [])
+            total = response.get("total", 0)
+            
+            if results:
+                response_text = f"Found {total} results for '{query}':\n\n"
+                for i, result in enumerate(results, 1):
+                    response_text += f"{i}. **{result.get('title', 'Untitled')}**\n"
+                    response_text += f"   {result.get('text', '')[:200]}...\n"
+                    response_text += f"   Source: {result.get('filename', 'Unknown')}\n"
+                    if result.get('score'):
+                        response_text += f"   Score: {result['score']}\n"
+                    response_text += "\n"
+            else:
+                response_text = f"No results found for '{query}'"
+            
+            return [TextContent(type="text", text=response_text)]
+            
+        except Exception as e:
+            return [TextContent(type="text", text=f"Error searching: {e}")]
+    
+    elif name == "get_chunk":
+        chunk_id = arguments.get("chunk_id", "")
+        
+        try:
+            response = await make_request(f"/chunks/{chunk_id}")
+            
+            if "error" in response:
+                return [TextContent(type="text", text=f"Error: {response['error']}")]
+            
+            if response:
+                result_text = f"**{response.get('title', 'Untitled')}**\n\n"
+                result_text += f"{response.get('text', '')}\n\n"
+                result_text += f"Source: {response.get('filename', 'Unknown')}\n"
+                result_text += f"URL: {response.get('url', 'N/A')}"
+                return [TextContent(type="text", text=result_text)]
+            else:
+                return [TextContent(type="text", text=f"Chunk {chunk_id} not found")]
+                
+        except Exception as e:
+            return [TextContent(type="text", text=f"Error getting chunk: {e}")]
+    
+    elif name == "list_docs":
+        try:
+            response = await make_request("/docs")
+            
+            if "error" in response:
+                return [TextContent(type="text", text=f"Error: {response['error']}")]
+            
+            docs = response.get("documents", [])
+            if docs:
+                response_text = "Available documents:\n\n"
+                for doc in docs:
+                    response_text += f"- **{doc.get('title', 'Untitled')}**\n"
+                    response_text += f"  ID: {doc.get('id', 'Unknown')}\n"
+                    response_text += f"  URL: {doc.get('url', 'N/A')}\n\n"
+            else:
+                response_text = "No documents available"
+            
+            return [TextContent(type="text", text=response_text)]
+            
+        except Exception as e:
+            return [TextContent(type="text", text=f"Error listing docs: {e}")]
+    
+    elif name == "health_check":
+        try:
+            response = await make_request("/")
+            
+            if "error" in response:
+                return [TextContent(type="text", text=f"Server error: {response['error']}")]
+            
+            status = response.get("status", "unknown")
+            chunks_loaded = response.get("chunks_loaded", 0)
+            docs_loaded = response.get("docs_loaded", 0)
+            
+            health_text = f"**Hugging Face Spaces Server Status**\n\n"
+            health_text += f"Status: {status}\n"
+            health_text += f"Chunks loaded: {chunks_loaded}\n"
+            health_text += f"Documents loaded: {docs_loaded}\n"
+            health_text += f"Server URL: {HF_SPACE_URL}"
+            
+            return [TextContent(type="text", text=health_text)]
+            
+        except Exception as e:
+            return [TextContent(type="text", text=f"Health check failed: {e}")]
+    
+    else:
+        return [TextContent(type="text", text=f"Unknown tool: {name}")]
+
+async def main():
+    """Main entry point"""
+    logger.info(f"Starting MCP client server for {HF_SPACE_URL}")
+    
+    # Run the server
+    async with stdio_server() as (read_stream, write_stream):
+        await server.run(
+            read_stream,
+            write_stream,
+            InitializationOptions(
+                server_name="mcp-docs-client",
+                server_version="1.0.0",
+                capabilities=server.get_capabilities(
+                    notification_options=None,
+                    experimental_capabilities=None
+                )
+            )
+        )
+
+if __name__ == "__main__":
+    asyncio.run(main())

mcp_server.py

@@ -0,0 +1,232 @@
+#!/usr/bin/env python3
+"""
+MCP Server for MCP Documentation
+Hosted on Hugging Face Spaces with HTTP transport
+"""
+
+import json
+import asyncio
+import logging
+from typing import Any, Dict, List, Optional
+from mcp.server import Server
+from mcp.server.models import InitializationOptions
+from mcp.server.sse import sse_server
+from mcp.types import (
+    Resource,
+    Tool,
+    TextContent,
+    LoggingLevel
+)
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Global data storage
+chunks_data = None
+docs_data = None
+
+def load_data():
+    """Load the documentation chunks and metadata"""
+    global chunks_data, docs_data
+    
+    try:
+        # Load chunks data
+        with open('mcp_docs/index/chunks_md.json', 'r', encoding='utf-8') as f:
+            chunks_data = json.load(f)
+        
+        # Load docs data
+        with open('mcp_docs/index/docs_md.json', 'r', encoding='utf-8') as f:
+            docs_data = json.load(f)
+        
+        logger.info(f"Loaded {len(chunks_data)} chunks and {len(docs_data)} documents")
+        
+    except Exception as e:
+        logger.error(f"Error loading data: {e}")
+        raise
+
+# Initialize the MCP server
+server = Server("mcp-docs-server")
+
+@server.list_resources()
+async def list_resources() -> List[Resource]:
+    """List available documentation resources"""
+    if not docs_data:
+        return []
+    
+    resources = []
+    for doc in docs_data:
+        resources.append(Resource(
+            uri=f"mcp://docs/{doc.get('id', 'unknown')}",
+            name=doc.get('title', 'Untitled'),
+            description=doc.get('content', '')[:200] + "..." if len(doc.get('content', '')) > 200 else doc.get('content', ''),
+            mimeType="text/plain"
+        ))
+    
+    return resources
+
+@server.read_resource()
+async def read_resource(uri: str) -> str:
+    """Read a specific documentation resource"""
+    if not chunks_data:
+        return "Data not loaded"
+    
+    # Extract document ID from URI
+    if uri.startswith("mcp://docs/"):
+        doc_id = uri.replace("mcp://docs/", "")
+        
+        # Find chunks for this document
+        doc_chunks = [chunk for chunk in chunks_data if chunk.get('doc_id') == doc_id]
+        
+        if doc_chunks:
+            # Combine all chunks for the document
+            content = "\n\n".join([chunk.get('text', '') for chunk in doc_chunks])
+            return content
+        else:
+            return f"Document {doc_id} not found"
+    
+    return "Invalid URI"
+
+@server.list_tools()
+async def list_tools() -> List[Tool]:
+    """List available tools"""
+    return [
+        Tool(
+            name="search_docs",
+            description="Search through MCP documentation chunks",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "Search query"
+                    },
+                    "limit": {
+                        "type": "integer",
+                        "description": "Maximum number of results",
+                        "default": 5
+                    }
+                },
+                "required": ["query"]
+            }
+        ),
+        Tool(
+            name="get_chunk",
+            description="Get a specific documentation chunk by ID",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "chunk_id": {
+                        "type": "string",
+                        "description": "Chunk ID to retrieve"
+                    }
+                },
+                "required": ["chunk_id"]
+            }
+        ),
+        Tool(
+            name="list_docs",
+            description="List all available documents",
+            inputSchema={
+                "type": "object",
+                "properties": {}
+            }
+        )
+    ]
+
+@server.call_tool()
+async def call_tool(name: str, arguments: Dict[str, Any]) -> List[TextContent]:
+    """Handle tool calls"""
+    if not chunks_data:
+        return [TextContent(type="text", text="Data not loaded")]
+    
+    if name == "search_docs":
+        query = arguments.get("query", "").lower()
+        limit = arguments.get("limit", 5)
+        
+        results = []
+        for chunk in chunks_data:
+            text = chunk.get('text', '').lower()
+            title = chunk.get('title', '').lower()
+            
+            # Simple scoring
+            score = 0
+            if query in text:
+                score += text.count(query) * 2
+            if query in title:
+                score += title.count(query) * 5
+            
+            if score > 0:
+                results.append({
+                    "chunk_id": chunk.get('chunk_id'),
+                    "title": chunk.get('title'),
+                    "text": chunk.get('text'),
+                    "url": chunk.get('url'),
+                    "filename": chunk.get('filename'),
+                    "score": score
+                })
+        
+        # Sort by score and limit results
+        results = sorted(results, key=lambda x: x['score'], reverse=True)[:limit]
+        
+        if results:
+            response = f"Found {len(results)} results for '{arguments.get('query', '')}':\n\n"
+            for i, result in enumerate(results, 1):
+                response += f"{i}. **{result['title']}** (Score: {result['score']})\n"
+                response += f"   {result['text'][:200]}...\n"
+                response += f"   Source: {result['filename']}\n\n"
+        else:
+            response = f"No results found for '{arguments.get('query', '')}'"
+        
+        return [TextContent(type="text", text=response)]
+    
+    elif name == "get_chunk":
+        chunk_id = arguments.get("chunk_id", "")
+        
+        for chunk in chunks_data:
+            if chunk.get('chunk_id') == chunk_id:
+                response = f"**{chunk.get('title', 'Untitled')}**\n\n"
+                response += f"{chunk.get('text', '')}\n\n"
+                response += f"Source: {chunk.get('filename', 'Unknown')}\n"
+                response += f"URL: {chunk.get('url', 'N/A')}"
+                return [TextContent(type="text", text=response)]
+        
+        return [TextContent(type="text", text=f"Chunk {chunk_id} not found")]
+    
+    elif name == "list_docs":
+        if not docs_data:
+            return [TextContent(type="text", text="No documents available")]
+        
+        response = "Available documents:\n\n"
+        for doc in docs_data:
+            response += f"- **{doc.get('title', 'Untitled')}**\n"
+            response += f"  ID: {doc.get('id', 'Unknown')}\n"
+            response += f"  URL: {doc.get('url', 'N/A')}\n\n"
+        
+        return [TextContent(type="text", text=response)]
+    
+    else:
+        return [TextContent(type="text", text=f"Unknown tool: {name}")]
+
+async def main():
+    """Main entry point"""
+    # Load data
+    load_data()
+    
+    # Run the server with SSE transport for HTTP access
+    async with sse_server() as (read_stream, write_stream):
+        await server.run(
+            read_stream,
+            write_stream,
+            InitializationOptions(
+                server_name="mcp-docs-server",
+                server_version="1.0.0",
+                capabilities=server.get_capabilities(
+                    notification_options=None,
+                    experimental_capabilities=None
+                )
+            )
+        )
+
+if __name__ == "__main__":
+    asyncio.run(main())

requirements.txt

@@ -1,4 +1 @@
-fastapi==0.104.1
-uvicorn==0.24.0
-pydantic==2.5.0
-python-multipart==0.0.6
+mcp==1.0.0

test_hf_connection.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+"""
+Test script to verify connection to Hugging Face Spaces server
+"""
+
+import asyncio
+import aiohttp
+import json
+
+HF_SPACE_URL = "https://galcan-mcp-docs-server.hf.space"
+
+async def test_connection():
+    """Test connection to Hugging Face Spaces server"""
+    print("Testing connection to Hugging Face Spaces server...")
+    print(f"URL: {HF_SPACE_URL}")
+    
+    try:
+        async with aiohttp.ClientSession() as session:
+            # Test health endpoint
+            print("\n1. Testing health endpoint...")
+            async with session.get(f"{HF_SPACE_URL}/") as response:
+                if response.status == 200:
+                    data = await response.json()
+                    print(f"[OK] Health check passed")
+                    print(f"   Status: {data.get('status', 'unknown')}")
+                    print(f"   Chunks loaded: {data.get('chunks_loaded', 0)}")
+                    print(f"   Docs loaded: {data.get('docs_loaded', 0)}")
+                else:
+                    print(f"[ERROR] Health check failed: {response.status}")
+                    return False
+            
+            # Test search endpoint
+            print("\n2. Testing search endpoint...")
+            search_data = {"query": "MCP architecture", "limit": 3}
+            async with session.post(f"{HF_SPACE_URL}/search", json=search_data) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    results = data.get('results', [])
+                    total = data.get('total', 0)
+                    print(f"[OK] Search test passed")
+                    print(f"   Found {total} results")
+                    if results:
+                        print(f"   First result: {results[0].get('title', 'Unknown')}")
+                else:
+                    print(f"[ERROR] Search test failed: {response.status}")
+                    return False
+            
+            # Test docs endpoint
+            print("\n3. Testing docs endpoint...")
+            async with session.get(f"{HF_SPACE_URL}/docs") as response:
+                if response.status == 200:
+                    data = await response.json()
+                    docs = data.get('documents', [])
+                    print(f"[OK] Docs endpoint working")
+                    print(f"   Found {len(docs)} documents")
+                else:
+                    print(f"[ERROR] Docs endpoint failed: {response.status}")
+                    return False
+            
+            print("\n[SUCCESS] All tests passed! Your Hugging Face Spaces server is working correctly.")
+            return True
+            
+    except Exception as e:
+        print(f"[ERROR] Connection failed: {e}")
+        return False
+
+async def main():
+    print("Hugging Face Spaces Connection Test")
+    print("=" * 50)
+    
+    success = await test_connection()
+    
+    if success:
+        print("\n✅ Your server is ready to use with Cursor!")
+        print("\nNext steps:")
+        print("1. Add the MCP client to your Cursor configuration")
+        print("2. Restart Cursor")
+        print("3. Use the tools: search_docs, get_chunk, list_docs, health_check")
+    else:
+        print("\n❌ Connection failed. Please check your Hugging Face Spaces deployment.")
+
+if __name__ == "__main__":
+    asyncio.run(main())

test_mcp_server.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+"""
+Test script for the MCP Documentation Server
+"""
+
+import json
+import subprocess
+import sys
+import os
+
+def test_data_loading():
+    """Test that data can be loaded"""
+    print("Testing data loading...")
+    
+    try:
+        # Test chunks data
+        with open('mcp_docs/index/chunks_md.json', 'r', encoding='utf-8') as f:
+            chunks = json.load(f)
+        print(f"[OK] Loaded {len(chunks)} chunks")
+        
+        # Test docs data
+        with open('mcp_docs/index/docs_md.json', 'r', encoding='utf-8') as f:
+            docs = json.load(f)
+        print(f"[OK] Loaded {len(docs)} documents")
+        
+        return True
+        
+    except Exception as e:
+        print(f"[ERROR] Error loading data: {e}")
+        return False
+
+def test_mcp_server_import():
+    """Test that the MCP server can be imported"""
+    print("\nTesting MCP server import...")
+    
+    try:
+        # Import the MCP server
+        from mcp_server import server, load_data
+        print("[OK] MCP server imported successfully")
+        
+        # Test data loading
+        load_data()
+        print("[OK] Data loading function works")
+        
+        print("[SUCCESS] MCP server is ready!")
+        return True
+        
+    except Exception as e:
+        print(f"[ERROR] Error importing MCP server: {e}")
+        return False
+
+def test_mcp_dependencies():
+    """Test that MCP dependencies are available"""
+    print("\nTesting MCP dependencies...")
+    
+    try:
+        import mcp
+        print("[OK] MCP SDK available")
+        
+        from mcp.server import Server
+        print("[OK] MCP Server class available")
+        
+        from mcp.server.stdio import stdio_server
+        print("[OK] MCP stdio server available")
+        
+        return True
+        
+    except ImportError as e:
+        print(f"[ERROR] MCP dependencies not available: {e}")
+        print("Install with: pip install mcp")
+        return False
+
+if __name__ == "__main__":
+    print("MCP Documentation Server - Test Script")
+    print("=" * 50)
+    
+    success = True
+    
+    # Test data loading
+    success &= test_data_loading()
+    
+    # Test MCP dependencies
+    success &= test_mcp_dependencies()
+    
+    # Test MCP server import
+    success &= test_mcp_server_import()
+    
+    if success:
+        print("\n[SUCCESS] All tests passed! The MCP server is ready for Cursor.")
+        print("\nTo use in Cursor:")
+        print("1. Add the server to your Cursor MCP configuration")
+        print("2. Restart Cursor")
+        print("3. Use the tools: search_docs, get_chunk, list_docs")
+        sys.exit(0)
+    else:
+        print("\n[FAILED] Some tests failed. Please check the errors above.")
+        sys.exit(1)