Add new app.py

app.py

@@ -1,187 +1,187 @@
-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 (may need: pip install mcp[sse] or sse-starlette)
-try:
-    from mcp.server.sse import SseServerTransport
-    from starlette.applications import Starlette
-    from starlette.routing import Route
-    from starlette.responses import Response
-    import uvicorn
-    SSE_AVAILABLE = True
-except ImportError:
-    SSE_AVAILABLE = False
-    print("Warning: SSE dependencies not available. Install with: pip install sse-starlette uvicorn")
-
-# Shared sentiment analysis function
-def sentiment_analysis(text: str) -> dict:
-    """
-    Analyze the sentiment of the given text.
-    
-    Returns:
-        dict: Contains polarity, subjectivity, and assessment
-    """
-    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
-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 the sentiment of text using TextBlob. Also exposes MCP server 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."],
-    ]
-)
-
-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")
-
-    # Create Starlette app for MCP
-    starlette_app = Starlette(
-        routes=[
-            Route("/sse", endpoint=handle_sse),
-            Route("/messages", endpoint=handle_messages, methods=["POST"]),
-        ]
-    )
-
-    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="info")
-
-    def main():
-        """Run both servers."""
-        import threading
-        
-        print("=" * 60)
-        print("Starting Combined Sentiment Analysis Server")
-        print("=" * 60)
-        print("📊 Gradio UI: http://localhost:7860")
-        print("🔌 MCP Server: http://localhost:8000/sse")
-        print("=" * 60)
-        
-        # 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
-        asyncio.sleep(1)
-        
-        # Start Gradio (blocking)
-        gradio_interface.launch(
-            server_name="0.0.0.0",
-            server_port=7860,
-            share=False
-        )
-
-else:
-    # Fallback: Gradio only if SSE not available
-    def main():
-        print("=" * 60)
-        print("SSE dependencies not installed. Running Gradio only.")
-        print("To enable MCP over HTTP, install: pip install sse-starlette uvicorn")
-        print("=" * 60)
-        print("📊 Gradio UI: http://localhost:7860")
-        print("=" * 60)
-        
-        gradio_interface.launch(
-            server_name="0.0.0.0",
-            server_port=7860,
-            share=False
-        )
-
-if __name__ == "__main__":
+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 (may need: pip install mcp[sse] or sse-starlette)
+try:
+    from mcp.server.sse import SseServerTransport
+    from starlette.applications import Starlette
+    from starlette.routing import Route
+    from starlette.responses import Response
+    import uvicorn
+    SSE_AVAILABLE = True
+except ImportError:
+    SSE_AVAILABLE = False
+    print("Warning: SSE dependencies not available. Install with: pip install sse-starlette uvicorn")
+
+# Shared sentiment analysis function
+def sentiment_analysis(text: str) -> dict:
+    """
+    Analyze the sentiment of the given text.
+    
+    Returns:
+        dict: Contains polarity, subjectivity, and assessment
+    """
+    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
+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 the sentiment of text using TextBlob. Also exposes MCP server 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."],
+    ]
+)
+
+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")
+
+    # Create Starlette app for MCP
+    starlette_app = Starlette(
+        routes=[
+            Route("/sse", endpoint=handle_sse),
+            Route("/messages", endpoint=handle_messages, methods=["POST"]),
+        ]
+    )
+
+    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="info")
+
+    def main():
+        """Run both servers."""
+        import threading
+        
+        print("=" * 60)
+        print("Starting Combined Sentiment Analysis Server")
+        print("=" * 60)
+        print("📊 Gradio UI: http://localhost:7860")
+        print("🔌 MCP Server: http://localhost:8000/sse")
+        print("=" * 60)
+        
+        # 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
+        asyncio.sleep(1)
+        
+        # Start Gradio (blocking)
+        gradio_interface.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=True
+        )
+
+else:
+    # Fallback: Gradio only if SSE not available
+    def main():
+        print("=" * 60)
+        print("SSE dependencies not installed. Running Gradio only.")
+        print("To enable MCP over HTTP, install: pip install sse-starlette uvicorn")
+        print("=" * 60)
+        print("📊 Gradio UI: http://localhost:7860")
+        print("=" * 60)
+        
+        gradio_interface.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=True
+        )
+
+if __name__ == "__main__":
     main()

requirements.txt

@@ -1,7 +1,4 @@
-gradio[mcp]
-textblob
-mcp
-sse-starlette
-uvicorn
-textblob
-gradio
+textblob
+mcp
+gradio
+starlette

run-agent.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+"""
+HuggingFace MCP Agent Runner
+
+This script provides a CLI interface to run HuggingFace MCP agents.
+Usage: python run-agent.py <agent-config.json>
+"""
+
+import sys
+import asyncio
+from pathlib import Path
+
+def main():
+    if len(sys.argv) != 2:
+        print("Usage: python run-agent.py <agent-config.json>")
+        print("Example: python run-agent.py my-agent/agent.json")
+        sys.exit(1)
+
+    config_path = sys.argv[1]
+    if not Path(config_path).exists():
+        print(f"Error: Config file '{config_path}' not found")
+        sys.exit(1)
+
+    try:
+        from huggingface_hub.inference._mcp.cli import run_agent
+        asyncio.run(run_agent(config_path))
+    except KeyboardInterrupt:
+        print("\nAgent stopped by user")
+    except Exception as e:
+        print(f"Error running agent: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()