j

app.py

@@ -416,5 +416,220 @@ async def mcp_sse():
         }
     )
 
+@app.post("/mcp/stream")
+async def mcp_post(request: dict):
+    """Handle MCP requests via POST (for mcp-remote bidirectional communication)"""
+    try:
+        method = request.get("method")
+        params = request.get("params", {})
+        request_id = request.get("id")
+        
+        if method == "tools/list":
+            return {
+                "jsonrpc": "2.0",
+                "id": request_id,
+                "result": {
+                    "tools": [
+                        {
+                            "name": "search_docs",
+                            "title": "Search Documentation",
+                            "description": "Search through MCP documentation chunks",
+                            "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"]
+                            }
+                        },
+                        {
+                            "name": "get_chunk",
+                            "title": "Get Documentation 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"]
+                            }
+                        },
+                        {
+                            "name": "list_docs",
+                            "title": "List Documents",
+                            "description": "List all available documents",
+                            "inputSchema": {
+                                "type": "object",
+                                "properties": {}
+                            }
+                        }
+                    ]
+                }
+            }
+        
+        elif method == "tools/call":
+            tool_name = params.get("name")
+            arguments = params.get("arguments", {})
+            
+            if tool_name == "search_docs":
+                query = arguments.get("query", "").lower()
+                limit = arguments.get("limit", 5)
+                
+                results = []
+                for chunk in chunks_data or []:
+                    text = chunk.get('text', '').lower()
+                    title = chunk.get('title', '').lower()
+                    
+                    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
+                        })
+                
+                results = sorted(results, key=lambda x: x['score'], reverse=True)[:limit]
+                
+                if results:
+                    response_text = f"Found {len(results)} results for '{query}':\n\n"
+                    for i, result in enumerate(results, 1):
+                        response_text += f"{i}. **{result['title']}** (Score: {result['score']})\n"
+                        response_text += f"   {result['text'][:200]}...\n"
+                        response_text += f"   Source: {result['filename']}\n\n"
+                else:
+                    response_text = f"No results found for '{query}'"
+                
+                return {
+                    "jsonrpc": "2.0",
+                    "id": request_id,
+                    "result": {
+                        "content": [
+                            {
+                                "type": "text",
+                                "text": response_text
+                            }
+                        ]
+                    }
+                }
+            
+            elif tool_name == "get_chunk":
+                chunk_id = arguments.get("chunk_id", "")
+                
+                for chunk in chunks_data or []:
+                    if chunk.get('chunk_id') == chunk_id:
+                        response_text = f"**{chunk.get('title', 'Untitled')}**\n\n"
+                        response_text += f"{chunk.get('text', '')}\n\n"
+                        response_text += f"Source: {chunk.get('filename', 'Unknown')}\n"
+                        response_text += f"URL: {chunk.get('url', 'N/A')}"
+                        
+                        return {
+                            "jsonrpc": "2.0",
+                            "id": request_id,
+                            "result": {
+                                "content": [
+                                    {
+                                        "type": "text",
+                                        "text": response_text
+                                    }
+                                ]
+                            }
+                        }
+                
+                return {
+                    "jsonrpc": "2.0",
+                    "id": request_id,
+                    "result": {
+                        "content": [
+                            {
+                                "type": "text",
+                                "text": f"Chunk {chunk_id} not found"
+                            }
+                        ]
+                    }
+                }
+            
+            elif tool_name == "list_docs":
+                if not docs_data:
+                    return {
+                        "jsonrpc": "2.0",
+                        "id": request_id,
+                        "result": {
+                            "content": [
+                                {
+                                    "type": "text",
+                                    "text": "No documents available"
+                                }
+                            ]
+                        }
+                    }
+                
+                response_text = "Available documents:\n\n"
+                for doc in docs_data:
+                    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"
+                
+                return {
+                    "jsonrpc": "2.0",
+                    "id": request_id,
+                    "result": {
+                        "content": [
+                            {
+                                "type": "text",
+                                "text": response_text
+                            }
+                        ]
+                    }
+                }
+            
+            else:
+                return {
+                    "jsonrpc": "2.0",
+                    "id": request_id,
+                    "error": {
+                        "code": -32601,
+                        "message": f"Unknown tool: {tool_name}"
+                    }
+                }
+        
+        else:
+            return {
+                "jsonrpc": "2.0",
+                "id": request_id,
+                "error": {
+                    "code": -32601,
+                    "message": f"Unknown method: {method}"
+                }
+            }
+    
+    except Exception as e:
+        return {
+            "jsonrpc": "2.0",
+            "id": request.get("id"),
+            "error": {
+                "code": -32603,
+                "message": f"Internal error: {str(e)}"
+            }
+        }
+
 if __name__ == "__main__":
     uvicorn.run(app, host="0.0.0.0", port=7860)