Upload 4 files

agent-config.py

@@ -0,0 +1,209 @@
+import json
+import asyncio
+from typing import Any
+from textblob import TextBlob
+import gradio as gr
+from mcp import Tool
+from mcp.server import Server
+from mcp.types import TextContent
+
+# Try to import SSE server
+try:
+    from mcp.server.sse import SseServerTransport
+    from starlette.applications import Starlette
+    from starlette.routing import Route, Mount
+    from starlette.responses import Response, JSONResponse
+    from starlette.middleware.cors import CORSMiddleware
+    import uvicorn
+    SSE_AVAILABLE = True
+except ImportError:
+    SSE_AVAILABLE = False
+    print("Warning: SSE dependencies not available.")
+
+# Shared sentiment analysis function
+def sentiment_analysis(text: str) -> dict:
+    """Analyze the sentiment of the given text."""
+    if not text or not text.strip():
+        return {
+            "error": "No text provided",
+            "polarity": 0,
+            "subjectivity": 0,
+            "assessment": "neutral"
+        }
+
+    blob = TextBlob(text)
+    sentiment = blob.sentiment
+
+    result = {
+        "polarity": round(sentiment.polarity, 2),
+        "subjectivity": round(sentiment.subjectivity, 2),
+        "assessment": "positive" if sentiment.polarity > 0 else "negative" if sentiment.polarity < 0 else "neutral"
+    }
+    return result
+
+# Gradio wrapper
+def sentiment_analysis_gradio(text: str) -> str:
+    """Gradio-compatible wrapper that returns JSON string."""
+    result = sentiment_analysis(text)
+    return json.dumps(result, indent=2)
+
+# Create MCP server
+mcp_server = Server("sentiment-analysis")
+
+@mcp_server.list_tools()
+async def handle_list_tools() -> list[Tool]:
+    """List available tools."""
+    return [
+        Tool(
+            name="analyze_sentiment",
+            description="Analyze the sentiment of text using TextBlob. Returns polarity (-1 to 1), subjectivity (0 to 1), and assessment (positive/negative/neutral).",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "text": {
+                        "type": "string",
+                        "description": "The text to analyze for sentiment"
+                    }
+                },
+                "required": ["text"]
+            }
+        )
+    ]
+
+@mcp_server.call_tool()
+async def handle_call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
+    """Handle tool calls."""
+    if name == "analyze_sentiment":
+        text = arguments.get("text", "")
+        result = sentiment_analysis(text)
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+    
+    return [TextContent(type="text", text=f"Unknown tool: {name}")]
+
+# Create Gradio interface with API access enabled
+gradio_interface = gr.Interface(
+    fn=sentiment_analysis_gradio,
+    inputs=gr.Textbox(
+        placeholder="Enter text to analyze...",
+        label="Input Text",
+        lines=5
+    ),
+    outputs=gr.Textbox(
+        label="Sentiment Analysis Result (JSON)",
+        lines=10
+    ),
+    title="Text Sentiment Analysis",
+    description="Analyze sentiment using TextBlob. MCP server available at http://localhost:8000/sse",
+    examples=[
+        ["I absolutely love this product! It's amazing and works perfectly."],
+        ["This is the worst experience I've ever had. Terrible service."],
+        ["The weather today is cloudy with a chance of rain."],
+    ],
+    api_name="analyze"  # Enable API access
+)
+
+if SSE_AVAILABLE:
+    # Create SSE endpoint for MCP
+    async def handle_sse(request):
+        """Handle SSE connections for MCP."""
+        transport = SseServerTransport("/messages")
+        
+        async with transport.connect_sse(
+            request.scope,
+            request.receive,
+            request._send
+        ) as streams:
+            await mcp_server.run(
+                streams[0],
+                streams[1],
+                mcp_server.create_initialization_options()
+            )
+        
+        return Response()
+
+    async def handle_messages(request):
+        """Handle message endpoint."""
+        return Response("MCP Server Ready", media_type="text/plain")
+    
+    async def handle_health(request):
+        """Health check endpoint."""
+        return JSONResponse({"status": "healthy", "service": "sentiment-analysis-mcp"})
+
+    # Create Starlette app for MCP
+    starlette_app = Starlette(
+        routes=[
+            Route("/sse", endpoint=handle_sse),
+            Route("/messages", endpoint=handle_messages, methods=["POST"]),
+            Route("/health", endpoint=handle_health, methods=["GET"]),
+        ]
+    )
+    
+    # Add CORS middleware
+    starlette_app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    def run_mcp_http_server():
+        """Run MCP server over HTTP."""
+        print("Starting MCP server on http://localhost:8000")
+        uvicorn.run(starlette_app, host="0.0.0.0", port=8000, log_level="warning")
+
+    def main():
+        """Run both servers."""
+        import threading
+        import time
+        
+        print("=" * 70)
+        print("🚀 Starting Combined Sentiment Analysis Server")
+        print("=" * 70)
+        print("📊 Gradio UI:     http://localhost:7860")
+        print("🔌 MCP Server:    http://localhost:8000/sse")
+        print("❤️  Health Check:  http://localhost:8000/health")
+        print("📡 Gradio API:    http://localhost:7860/api/analyze")
+        print("=" * 70)
+        print("\nConfiguration for agent.json:")
+        print(json.dumps({
+            "servers": [{
+                "type": "sse",
+                "url": "http://localhost:8000/sse"
+            }]
+        }, indent=2))
+        print("=" * 70)
+        
+        # Start MCP server in separate thread
+        mcp_thread = threading.Thread(target=run_mcp_http_server, daemon=True)
+        mcp_thread.start()
+        
+        # Give MCP server time to start
+        time.sleep(2)
+        
+        # Start Gradio (blocking)
+        gradio_interface.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False,
+            show_error=True
+        )
+
+else:
+    # Fallback: Gradio only if SSE not available
+    def main():
+        print("=" * 70)
+        print("⚠️  SSE dependencies not installed. Running Gradio only.")
+        print("To enable MCP over HTTP, install: pip install sse-starlette uvicorn")
+        print("=" * 70)
+        print("📊 Gradio UI: http://localhost:7860")
+        print("=" * 70)
+        
+        gradio_interface.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False
+        )
+
+if __name__ == "__main__":
+    main()

agent.json

@@ -1,11 +1,13 @@
 {
-	"model": "Qwen/Qwen3-32B",
-	"endpointUrl": "https://borodache-sentiment-analysis-mcp.huggingface.co/v1/",
-	"servers": [
-		{
-			"type": "stdio",
-            "command": "npx",
-			"args": ["http://localhost:7860"]
-		}
-	]
+    "model": "Qwen/Qwen3-32B",
+    "endpointUrl": "https://borodache-sentiment-analysis-mcp.huggingface.co/v1/",
+    "servers": 
+    [
+        {
+            "type": "sse",
+            "url": "http://localhost:8000/sse",
+            "name": "sentiment-analysis",
+            "description": "Sentiment analysis using TextBlob"
+        }
+    ]
 }

requirements.txt

@@ -2,3 +2,6 @@ textblob
 mcp
 gradio
 starlette
+sse-starlette 
+uvicorn
+starlette