rename app.py

app.py

@@ -0,0 +1,192 @@
+import os
+from datetime import datetime
+from typing import List, Dict, Any, Optional
+
+from fastapi import FastAPI, Request, BackgroundTasks
+from fastapi.middleware.cors import CORSMiddleware
+import gradio as gr
+import uvicorn
+from pydantic import BaseModel
+from huggingface_hub.inference._mcp.agent import Agent
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Configuration
+WEBHOOK_SECRET = os.getenv("WEBHOOK_SECRET", "your-webhook-secret")
+HF_TOKEN = os.getenv("HF_TOKEN")
+HF_MODEL = os.getenv("HF_MODEL", "microsoft/DialoGPT-medium")
+HF_PROVIDER = os.getenv("HF_PROVIDER", "huggingface")
+
+# Simple storage for processed comments
+comments_store: List[Dict[str, Any]] = []
+
+# Agent instance
+agent_instance: Optional[Agent] = None
+
+
+class WebhookEvent(BaseModel):
+    event: Dict[str, str]
+    comment: Dict[str, Any]
+    discussion: Dict[str, Any]
+    repo: Dict[str, str]
+
+
+app = FastAPI(title="HF Discussion Bot")
+app.add_middleware(CORSMiddleware, allow_origins=["*"])
+
+
+async def get_agent():
+    """Get or create Agent instance"""
+    global agent_instance
+    if agent_instance is None and HF_TOKEN:
+        agent_instance = Agent(
+            model=HF_MODEL,
+            provider=HF_PROVIDER,
+            api_key=HF_TOKEN,
+            servers=[
+                {
+                    "type": "stdio",
+                    "config": {"command": "python", "args": ["mcp_server.py"]},
+                }
+            ],
+        )
+        await agent_instance.load_tools()
+    return agent_instance
+
+
+async def process_webhook_comment(webhook_data: Dict[str, Any]):
+    """Process webhook using Agent with MCP tools"""
+    comment_content = webhook_data["comment"]["content"]
+    discussion_title = webhook_data["discussion"]["title"]
+    repo_name = webhook_data["repo"]["name"]
+    discussion_num = webhook_data["discussion"]["num"]
+
+    agent = await get_agent()
+    if not agent:
+        ai_response = "Error: Agent not configured (missing HF_TOKEN)"
+    else:
+        # Use Agent to respond to the discussion
+        prompt = f"""
+        Please respond to this HuggingFace discussion comment using the available tools.
+        
+        Repository: {repo_name}
+        Discussion: {discussion_title} (#{discussion_num})
+        Comment: {comment_content}
+        
+        First use generate_discussion_response to create a helpful response, then use post_discussion_comment to post it.
+        """
+
+        try:
+            response_parts = []
+            async for item in agent.run(prompt):
+                # Collect the agent's response
+                if hasattr(item, "content") and item.content:
+                    response_parts.append(item.content)
+                elif isinstance(item, str):
+                    response_parts.append(item)
+
+            ai_response = (
+                " ".join(response_parts) if response_parts else "No response generated"
+            )
+        except Exception as e:
+            ai_response = f"Error using agent: {str(e)}"
+
+    # Store the interaction with reply link
+    discussion_url = f"https://huggingface.co/{repo_name}/discussions/{discussion_num}"
+
+    interaction = {
+        "timestamp": datetime.now().isoformat(),
+        "repo": repo_name,
+        "discussion_title": discussion_title,
+        "discussion_num": discussion_num,
+        "discussion_url": discussion_url,
+        "original_comment": comment_content,
+        "ai_response": ai_response,
+        "comment_author": webhook_data["comment"]["author"],
+    }
+
+    comments_store.append(interaction)
+    return ai_response
+
+
+@app.post("/webhook")
+async def webhook_handler(request: Request, background_tasks: BackgroundTasks):
+    """Handle HF Hub webhooks"""
+    webhook_secret = request.headers.get("X-Webhook-Secret")
+    if webhook_secret != WEBHOOK_SECRET:
+        return {"error": "Invalid webhook secret"}
+
+    payload = await request.json()
+    event = payload.get("event", {})
+
+    if event.get("action") == "create" and event.get("scope") == "discussion.comment":
+        background_tasks.add_task(process_webhook_comment, payload)
+        return {"status": "processing"}
+
+    return {"status": "ignored"}
+
+
+async def simulate_webhook(
+    repo_name: str, discussion_title: str, comment_content: str
+) -> str:
+    """Simulate webhook for testing"""
+    if not all([repo_name, discussion_title, comment_content]):
+        return "Please fill in all fields."
+
+    mock_payload = {
+        "event": {"action": "create", "scope": "discussion.comment"},
+        "comment": {
+            "content": comment_content,
+            "author": "test-user",
+            "created_at": datetime.now().isoformat(),
+        },
+        "discussion": {
+            "title": discussion_title,
+            "num": len(comments_store) + 1,
+        },
+        "repo": {"name": repo_name},
+    }
+
+    response = await process_webhook_comment(mock_payload)
+    return f"✅ Processed! AI Response: {response}"
+
+
+def create_gradio_app():
+    """Create Gradio interface"""
+    with gr.Blocks(title="HF Discussion Bot", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# 🤖 HF Discussion Bot Dashboard")
+        gr.Markdown("*Powered by HuggingFace Tiny Agents + FastMCP*")
+
+        with gr.Column():
+            sim_repo = gr.Textbox(label="Repository", value="microsoft/DialoGPT-medium")
+            sim_title = gr.Textbox(label="Discussion Title", value="Test Discussion")
+            sim_comment = gr.Textbox(
+                label="Comment",
+                lines=3,
+                value="How do I use this model?",
+            )
+            sim_btn = gr.Button("📤 Test Webhook")
+
+        with gr.Column():
+            sim_result = gr.Textbox(label="Result", lines=8)
+
+        sim_btn.click(
+            fn=simulate_webhook,
+            inputs=[sim_repo, sim_title, sim_comment],
+            outputs=[sim_result],
+        )
+
+    return demo
+
+
+# Mount Gradio app
+gradio_app = create_gradio_app()
+app = gr.mount_gradio_app(app, gradio_app, path="/gradio")
+
+
+if __name__ == "__main__":
+    print("🚀 Starting HF Discussion Bot with Tiny Agents...")
+    print("📊 Dashboard: http://localhost:8001/gradio")
+    print("🔗 Webhook: http://localhost:8001/webhook")
+    uvicorn.run("server:app", host="0.0.0.0", port=8001, reload=True)