Adding Agent

.gitignore

@@ -0,0 +1,2 @@
+# Environment variables
+.env

README.md

@@ -1,14 +1,42 @@
 ---
 title: Collective Intelligence Orchestrator
-emoji: 🚀
-colorFrom: indigo
+emoji: 🐢
+colorFrom: purple
 colorTo: indigo
 sdk: gradio
 sdk_version: 5.33.1
 app_file: app.py
 pinned: false
 license: apache-2.0
-short_description: Activate a living swarm of AI agents.
+short_description: Gradio-based interface coordinates a network of agents
 ---
 
+# Collective Intelligence Orchestrator
+
+This Gradio-based interface coordinates a network of autonomous AI agents using Hugging Face's MCP protocol.
+
+## Agents in the Network:
+- Climate Sensor
+- Policy Modeler
+- Economic Forecast
+- Media Monitor
+- Public Health
+- NGO Matcher
+
+Submit a real-world scenario, and watch the swarm collaborate in real time.
+
+## Test Case Example:
+Input:
+
+- “Massive flooding in coastal Bangladesh, affecting over 200,000 residents. Power outages, displacement, and rising waterborne diseases reported.”
+
+Expected output:
+
+- Climate Sensor: Critical anomaly detected.
+- Policy Modeler: Emergency zoning, sanitation relief, medical deployment.
+- Economic Forecast: Estimated GDP loss, recovery timeline.
+- Media Monitor: High sentiment panic, moderate misinfo risk.
+- Public Health: Cholera risk, hospital overload.
+- NGO Matcher: Suggest 2–3 orgs that can help.
+
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

agents_registry.json

@@ -0,0 +1,114 @@
+{
+  "version": "1.0.0",
+  "last_updated": "2025-06-10T08:47:58Z",
+  "agents": [
+    {
+      "id": "ngo-matcher-001",
+      "name": "NGO Matcher",
+      "description": "Matches humanitarian needs with relevant NGOs and aid organizations",
+      "endpoint": "https://dtka-collective-intelligence-ngo-matching-agent.hf.space/agent",
+      "file_url": "https://huggingface.co/spaces/dtka/collective-intelligence-ngo-matching-agent/resolve/main/",
+      "icon": "🤝",
+      "api_spec": "/openapi.json",
+      "type": "matching",
+      "categories": ["humanitarian", "coordination"],
+      "tags": ["ngo", "aid", "matching"],
+      "status": "active",
+      "version": "1.0.0",
+      "capabilities": ["ngo_matching", "resource_allocation"],
+      "rate_limit": 100,
+      "timeout_seconds": 30,
+      "auth_required": false
+    },
+    {
+      "id": "media-monitor-001",
+      "name": "Media Monitor",
+      "description": "Tracks and analyzes media coverage and social media for crisis events",
+      "endpoint": "https://dtka-collective-intelligence-media-monitoring-agent.hf.space/agent",
+      "file_url": "https://huggingface.co/spaces/dtka/collective-intelligence-media-monitoring-agent/resolve/main/",
+      "icon": "📰",
+      "api_spec": "/openapi.json",
+      "type": "monitoring",
+      "categories": ["media", "sentiment_analysis"],
+      "tags": ["news", "social_media", "sentiment"],
+      "status": "active",
+      "version": "1.0.0",
+      "capabilities": ["news_aggregation", "sentiment_analysis", "trend_detection"],
+      "rate_limit": 200,
+      "timeout_seconds": 20,
+      "auth_required": false
+    },
+    {
+      "id": "policy-modeler-001",
+      "name": "Policy Modeler",
+      "description": "Models policy impacts and suggests regulatory responses to crises",
+      "endpoint": "https://dtka-collective-intelligence-policy-modeler-agent.hf.space/agent",
+      "file_url": "https://huggingface.co/spaces/dtka/collective-intelligence-policy-modeler-agent/resolve/main/",
+      "icon": "📜",
+      "api_spec": "/openapi.json",
+      "type": "modeling",
+      "categories": ["policy", "regulation"],
+      "tags": ["policy_analysis", "regulations", "impact_modeling"],
+      "status": "active",
+      "version": "1.0.0",
+      "capabilities": ["policy_simulation", "impact_analysis"],
+      "rate_limit": 50,
+      "timeout_seconds": 45,
+      "auth_required": true
+    },
+    {
+      "id": "climate-sensor-001",
+      "name": "Climate Sensor",
+      "description": "Monitors and analyzes environmental and climate-related data",
+      "endpoint": "https://dtka-collective-intelligence-climate-sensor.hf.space/agent",
+      "file_url": "https://huggingface.co/spaces/dtka/collective-intelligence-climate-sensor/resolve/main/",
+      "icon": "🌦️",
+      "api_spec": "/openapi.json",
+      "type": "monitoring",
+      "categories": ["environment", "climate"],
+      "tags": ["sensor_data", "environmental_monitoring", "climate_data"],
+      "status": "active",
+      "version": "1.0.0",
+      "capabilities": ["sensor_data_analysis", "anomaly_detection"],
+      "rate_limit": 150,
+      "timeout_seconds": 25,
+      "auth_required": false
+    },
+    {
+      "id": "public-health-001",
+      "name": "Public Health",
+      "description": "Tracks and analyzes public health data and disease outbreaks",
+      "endpoint": "https://dtka-collective-intelligence-public-health-agent.hf.space/agent",
+      "file_url": "https://huggingface.co/spaces/dtka/collective-intelligence-public-health-agent/resolve/main/",
+      "icon": "🏥",
+      "api_spec": "/openapi.json",
+      "type": "analysis",
+      "categories": ["health", "epidemiology"],
+      "tags": ["disease_tracking", "healthcare", "outbreak_analysis"],
+      "status": "active",
+      "version": "1.0.0",
+      "capabilities": ["disease_surveillance", "risk_assessment"],
+      "rate_limit": 75,
+      "timeout_seconds": 35,
+      "auth_required": true
+    },
+    {
+      "id": "economic-forecast-001",
+      "name": "Economic Forecast",
+      "description": "Provides economic impact analysis and forecasting for crisis scenarios",
+      "endpoint": "https://dtka-collective-intelligence-economic-forecast-agent.hf.space/agent",
+      "file_url": "https://huggingface.co/spaces/dtka/collective-intelligence-economic-forecast-agent/resolve/main/",
+      "icon": "💹",
+      "api_spec": "/openapi.json",
+      "type": "forecasting",
+      "categories": ["economics", "finance"],
+      "tags": ["economic_analysis", "forecasting", "impact_assessment"],
+      "status": "active",
+      "version": "1.0.0",
+      "capabilities": ["economic_modeling", "trend_analysis"],
+      "rate_limit": 60,
+      "timeout_seconds": 40,
+      "auth_required": true
+    }
+  ]
+}

app.py

@@ -0,0 +1,359 @@
+import os
+import requests
+import gradio as gr
+import anthropic
+import yaml
+import hashlib
+import json
+
+# Anthropic API Setup
+anthropic_client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
+
+# ---- Agent Discovery Logic ----
+
+AGENT_ICONS = {
+    "Climate Sensor": "🌦️",
+    "Policy Modeler": "📜",
+    "Economic Forecast": "💹",
+    "Media Monitor": "📰",
+    "Public Health": "🏥",
+    "NGO Matcher": "🤝"
+}
+
+def fetch_registry():
+    # Load from local file first, fall back to remote if not found
+    local_registry = "agents_registry.json"
+    if os.path.exists(local_registry):
+        print("Loading agents from local registry file")
+        try:
+            with open(local_registry, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except Exception as e:
+            print(f"Error loading local registry: {e}")
+    
+    # Fall back to remote registry
+    remote_url = "https://huggingface.co/spaces/dtka/collective-intelligence-orchestrator/resolve/main/agents_registry.json"
+    print(f"Fetching agents from remote registry: {remote_url}")
+    try:
+        res = requests.get(remote_url, timeout=5)
+        res.raise_for_status()
+        return res.json()
+    except Exception as e:
+        print(f"Error fetching remote registry: {e}")
+        return None
+
+def fetch_agent_yaml(space_url):
+    try:
+        res = requests.get(f"{space_url}/agent.yaml")
+        return yaml.safe_load(res.text)
+    except:
+        return None
+
+def compute_agent_embedding(text):
+    # Handle None or empty input
+    if not text:
+        return 0
+    # Simulated embedding using a hash — replace with real embedding logic if desired
+    return int(hashlib.md5(text.encode()).hexdigest(), 16) % 10000
+
+def discover_agents_from_registry():
+    registry = fetch_registry()
+    if not registry or 'agents' not in registry:
+        print("No valid registry data found")
+        return [], [], []
+        
+    tools = []
+    cards = []
+    index = []
+    
+    for agent in registry['agents']:
+        if not agent.get('status') == 'active':
+            continue
+            
+        try:
+            # Use metadata from registry or fetch from agent if needed
+            name = agent.get('name', 'Unnamed Agent')
+            description = agent.get('description', 'No description available')
+            endpoint = agent.get('endpoint')
+            icon = agent.get('icon', '')
+
+            # Create tool function using the agent's endpoint
+            def tool_func(input_text, agent_endpoint=endpoint, agent_name=name):
+                try:
+                    resp = requests.post(
+                        agent_endpoint,
+                        json={"input": input_text},
+                        timeout=agent.get('timeout_seconds', 30)
+                    )
+                    resp.raise_for_status()
+                    return resp.json().get("output", "No structured output.")
+                except Exception as e:
+                    print(f"Error calling {agent_name} agent: {str(e)}")
+                    return f"Error: Failed to call {agent_name} agent - {str(e)}"
+
+            # Compute embedding for semantic search
+            emb = compute_agent_embedding(f"{name} {description} {' '.join(agent.get('tags', []))}")
+            
+            # Add to tools with all necessary metadata
+            tools.append((
+                name,
+                icon,
+                description,
+                tool_func,
+                emb,
+                agent.get('categories', []),
+                agent.get('capabilities', [])
+            ))
+            
+            # Update index for semantic search
+            index.append((emb, name))
+            
+            # Add card for UI
+            cards.append((icon, name, description, agent.get('categories', [])))
+            
+        except Exception as e:
+            print(f"Error processing agent {agent.get('name', 'unknown')}: {str(e)}")
+            continue
+            
+    print(f"Successfully loaded {len(tools)} agents from registry")
+    return tools, cards, index
+
+# ---- Claude Orchestrator ----
+
+def match_agents_by_vector(input_text, tools, index):
+    if not tools or not index:
+        return []
+        
+    input_emb = compute_agent_embedding(input_text)
+    
+    # Calculate similarity scores for all agents
+    scored_agents = []
+    for i, (emb, name) in enumerate(index):
+        # Simple similarity based on vector distance
+        similarity = 1 / (1 + abs(emb - input_emb))
+        scored_agents.append((similarity, tools[i]))
+    
+    # Sort by similarity score (descending)
+    scored_agents.sort(reverse=True, key=lambda x: x[0])
+    
+    # Return top matching agents (above threshold or top 3)
+    threshold = 0.3  # Adjust based on your needs
+    return [agent for score, agent in scored_agents if score > threshold][:5]  # Limit to top 5 matches
+
+def claude_conductor(message, history, tools=None, index=None):
+    if tools is None:
+        tools = []
+    if index is None:
+        index = []
+
+    selected_tools = match_agents_by_vector(message, tools, index)
+
+    tools_description = "\n".join(
+        f"- {icon} {name}: {desc} (Categories: {', '.join(categories) if categories else 'None'})"
+        for name, icon, desc, _, _, categories, _ in selected_tools
+    ) if selected_tools else "No relevant tools matched."
+
+    # Format the conversation history for Claude
+    conversation = []
+    for user_msg, bot_msg in history:
+        if user_msg:
+            conversation.append({"role": "user", "content": user_msg})
+        if bot_msg:
+            conversation.append({"role": "assistant", "content": bot_msg})
+    
+    # Add the current user message
+    conversation.append({"role": "user", "content": message})
+
+    # Create system prompt
+    system_prompt = """You are a coordinator of autonomous AI agents solving real-world crises.
+Analyze the user's input and determine which tools to use to gather information.
+Here are the available agents for this task:
+{tools_description}
+Provide a clear, concise response based on the available information."""
+
+    try:
+        # Call Claude API
+        response = anthropic_client.messages.create(
+            model="claude-3-sonnet-20240229",
+            max_tokens=1000,
+            system=system_prompt,
+            messages=conversation,
+            temperature=0.7
+        )
+
+        # Return the response text
+        if response.content and len(response.content) > 0:
+            return response.content[0].text
+        return "I couldn't generate a response. Please try again."
+
+    except Exception as e:
+        print(f"Error calling Claude API: {str(e)}")
+        return f"An error occurred while processing your request: {str(e)}"
+
+# ---- Launch Gradio ChatInterface ----
+
+if __name__ == "__main__":
+    print("Starting application...")
+    tools, cards, index = discover_agents_from_registry()
+    print(f"Discovered {len(tools)} tools, {len(cards)} cards, {len(index)} index entries")
+    if not tools:
+        print("WARNING: No tools discovered. The UI may not display correctly.")
+
+    with gr.Blocks(
+        theme=gr.themes.Soft(primary_hue="blue", secondary_hue="cyan"),
+        title="Collective Intelligence Orchestrator"
+    ) as demo:
+        gr.Markdown("""
+        # 🧠 Collective Intelligence Orchestrator
+        _Activate a living swarm of AI agents._
+
+        Enter a real-world scenario (e.g., natural disaster, policy failure, humanitarian crisis), and let the orchestrator dynamically coordinate a swarm response using multiple autonomous MCP agents.
+
+        **Author**: [@dtka](https://huggingface.co/dtka)  
+        **Project Docs**: [GitHub Repo](https://github.com/dtka/collective-intelligence-networks)  
+        **Hackathon**: [Hugging Face MCP Hackathon](https://huggingface.co/Agents-MCP-Hackathon)
+        """)
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### 🧩 Available Agents")
+                if not cards:
+                    gr.Markdown("⚠️ No agents discovered. Please check agents_registry.json or try again later.")
+                for icon, name, desc, categories in cards:
+                    categories_html = f"<br><span style='font-size: 0.8em; color: #666;'><i>Categories: {', '.join(categories) if categories else 'General'}</i></span>" if categories else ""
+                    gr.Markdown(
+                        f"<b>{icon} {name}</b><br>"
+                        f"<span style='font-size: 0.9em;'>{desc}</span>"
+                        f"{categories_html}",
+                        render=True,
+                        elem_id="agent-card"
+                    )
+
+            with gr.Column(scale=2):
+                # Create the chat interface with explicit buttons
+                with gr.Row():
+                    with gr.Column(scale=8):
+                        # Chatbot display
+                        chatbot = gr.Chatbot(
+                            height=500,
+                            show_copy_button=True,
+                            show_label=False,
+                            container=True,
+                            bubble_full_width=True,
+                            placeholder="Start a conversation...",
+                            elem_id="chatbot"
+                        )
+                        
+                        # Input area with buttons
+                        with gr.Row():
+                            msg = gr.Textbox(
+                                placeholder="Describe a crisis or scenario...",
+                                container=False,
+                                scale=8,
+                                min_width=200,
+                                show_label=False
+                            )
+                            submit_btn = gr.Button("Send to Swarm", variant="primary", scale=1)
+                            stop_btn = gr.Button("Stop", variant="stop", scale=1, visible=False)
+                        
+                        # Additional buttons
+                        with gr.Row():
+                            clear_btn = gr.Button("Clear Chat")
+                            retry_btn = gr.Button("Retry")
+                    
+                    # Format messages for the chat interface
+                    def format_messages(history):
+                        formatted = []
+                        for user_msg, bot_msg in history:
+                            if user_msg:
+                                formatted.append((user_msg, None))
+                            if bot_msg is not None:
+                                if formatted and formatted[-1][1] is None:
+                                    formatted[-1] = (formatted[-1][0], bot_msg)
+                                else:
+                                    formatted.append((None, bot_msg))
+                        return formatted
+                    
+                    # Set up button click handlers
+                    def user(user_message, history):
+                        if not user_message.strip():
+                            return "", history
+                        return "", history + [[user_message, None]]
+                    
+                    def bot(history):
+                        if not history or not history[-1][0]:
+                            return history
+                        
+                        # Get the current message and previous conversation
+                        current_message = history[-1][0]
+                        prev_messages = history[:-1]
+                        
+                        # Format history for Claude
+                        formatted_history = []
+                        for user_msg, bot_msg in prev_messages:
+                            if user_msg:
+                                formatted_history.append((user_msg, bot_msg or ""))
+                        
+                        # Get response from Claude
+                        try:
+                            bot_message = claude_conductor(current_message, formatted_history, tools, index)
+                            history[-1][1] = bot_message
+                        except Exception as e:
+                            print(f"Error in bot response: {e}")
+                            history[-1][1] = "Sorry, I encountered an error. Please try again."
+                        
+                        return history
+                    
+                    # Message submission handler
+                    def process_message(user_message, history):
+                        if not user_message.strip():
+                            return "", history
+                        history = history + [[user_message, None]]
+                        return "", history
+                    
+                    # Connect UI elements
+                    submit_event = msg.submit(
+                        process_message,
+                        [msg, chatbot],
+                        [msg, chatbot],
+                        queue=False
+                    ).then(
+                        bot,
+                        chatbot,
+                        chatbot
+                    )
+                    
+                    submit_btn.click(
+                        process_message,
+                        [msg, chatbot],
+                        [msg, chatbot],
+                        queue=False
+                    ).then(
+                        bot,
+                        chatbot,
+                        chatbot
+                    )
+                    
+                    # Clear chat button
+                    clear_btn.click(lambda: [], None, chatbot, queue=False)
+                    
+                    # Retry button
+                    def retry_last(history):
+                        if not history:
+                            return history
+                        if history[-1][1] is not None:
+                            history[-1][1] = None
+                        return history
+                    
+                    retry_btn.click(
+                        retry_last,
+                        chatbot,
+                        chatbot,
+                        queue=False
+                    ).then(
+                        bot,
+                        chatbot,
+                        chatbot
+                    )
+
+    demo.launch()

requirements.txt

@@ -0,0 +1,4 @@
+gradio==5.33.1
+requests==2.32.3
+pyyaml==6.0.2
+anthropic==0.53.0

utils/discovery.py

@@ -0,0 +1,32 @@
+import requests
+import gradio as gr
+import yaml
+
+def fetch_agent_yaml(space_url):
+    try:
+        res = requests.get(f"{space_url}/agent.yaml")
+        return yaml.safe_load(res.text)
+    except:
+        return None
+
+def build_agent_tool(agent_info, endpoint_url):
+    def tool_func(input_text):
+        try:
+            resp = requests.post(f"{endpoint_url}/agent", json={"input": input_text}, timeout=10)
+            return resp.json().get("output", "No structured output.")
+        except Exception as e:
+            return f"Error: {str(e)}"
+
+    return gr.TextTool(
+        name=agent_info.get("name", "Unnamed Agent"),
+        description=agent_info.get("description", "No description."),
+        func=tool_func
+    )
+
+def discover_agents_from_urls(agent_urls):
+    tools = []
+    for url in agent_urls:
+        metadata = fetch_agent_yaml(url)
+        if metadata:
+            tools.append(build_agent_tool(metadata, url))
+    return tools