Update app.py

app.py

@@ -1,239 +1,101 @@
-import os
-from dotenv import load_dotenv
 import gradio as gr
-from proctor import (
-    CompositeTechnique,
-    RolePrompting,
-    ChainOfThought,
-    ChainOfVerification,
-    SelfAsk,
-    EmotionPrompting,
-    list_techniques,
-)
+import requests
 
-# Load environment variables (.env should contain OPENROUTER_API_KEY)
-load_dotenv()
-openrouter_key = os.environ.get("OPENROUTER_API_KEY")
+COINGECKO_API_BASE = "https://api.coingecko.com/api/v3"
 
-# Check API key
-if not openrouter_key:
-    raise RuntimeError(
-        "❌ OPENROUTER_API_KEY not set. Please set it in your .env file."
-    )
-
-# ----- Model Configs -----
-MODEL_CONFIGS = {
-    "gemini": {
-        "model": "openrouter/google/gemini-2.5-flash-preview-05-20",
-        "api_base": "https://openrouter.ai/api/v1",
-        "api_key": openrouter_key,
-        "temperature": 0.3,
-        "max_tokens": 1500,
-    },
-    "claude": {
-        "model": "openrouter/anthropic/claude-sonnet-4",
-        "api_base": "https://openrouter.ai/api/v1",
-        "api_key": openrouter_key,
-        "temperature": 0.7,
-        "max_tokens": 2000,
-    },
-    "deepseek": {
-        "model": "openrouter/deepseek/deepseek-r1-0528",
-        "api_base": "https://openrouter.ai/api/v1",
-        "api_key": openrouter_key,
-        "temperature": 0.6,
-        "max_tokens": 3000,
-    },
-    "llama": {
-        "model": "openrouter/meta-llama/llama-4-scout",
-        "api_base": "https://openrouter.ai/api/v1",
-        "api_key": openrouter_key,
-        "temperature": 0.6,
-        "max_tokens": 2500,
-    },
-    "mistral": {
-        "model": "openrouter/mistralai/mistral-small-3.1-24b-instruct",
-        "api_base": "https://openrouter.ai/api/v1",
-        "api_key": openrouter_key,
-        "temperature": 0.8,
-        "max_tokens": 1000,
-    },
-}
-
-# ----- Tool Functions -----
-
-def proctor_expert_cot(problem: str) -> dict:
-    """
-    Chain-of-Thought, Verification, and Role Prompting on Gemini.
-    """
-    technique = CompositeTechnique(
-        name="Expert Chain-of-Thought",
-        identifier="custom-expert-cot",
-        techniques=[
-            RolePrompting(),
-            ChainOfThought(),
-            ChainOfVerification(),
-        ],
-    )
-    response = technique.execute(
-        problem,
-        llm_config=MODEL_CONFIGS["gemini"],
-        role="Expert House Builder and Construction Manager"
-    )
-    return {
-        "model": "Google Gemini 2.5 Flash",
-        "technique": "Expert Chain-of-Thought",
-        "response": response
-    }
-
-def proctor_claude_cot(problem: str) -> dict:
-    """
-    Chain-of-Thought with Claude 4 Sonnet.
-    """
-    technique = ChainOfThought()
-    response = technique.execute(problem, llm_config=MODEL_CONFIGS["claude"])
-    return {
-        "model": "Claude 4 Sonnet",
-        "technique": "Chain-of-Thought",
-        "response": response
-    }
-
-def proctor_deepseek_reasoning(problem: str) -> dict:
-    """
-    Deep reasoning with DeepSeek R1: CoT, SelfAsk, Verification.
-    """
-    technique = CompositeTechnique(
-        name="Deep Reasoning Analysis",
-        identifier="deep-reasoning",
-        techniques=[
-            ChainOfThought(),
-            SelfAsk(),
-            ChainOfVerification(),
-        ],
-    )
-    response = technique.execute(problem, llm_config=MODEL_CONFIGS["deepseek"])
-    return {
-        "model": "DeepSeek R1",
-        "technique": "Deep Reasoning Analysis",
-        "response": response
-    }
-
-def proctor_llama_emotion(problem: str) -> dict:
+def get_current_price(coin_id: str = "bitcoin", vs_currency: str = "usd") -> dict:
     """
-    Emotion Prompting with Llama 4 Scout.
+    Get the current price of a cryptocurrency in a given currency.
+    Args:
+        coin_id (str): CoinGecko coin ID (e.g. 'bitcoin', 'ethereum')
+        vs_currency (str): Fiat currency (e.g. 'usd', 'eur')
+    Returns:
+        dict: Current price and other info, or error message.
     """
-    technique = EmotionPrompting()
-    response = technique.execute(
-        problem,
-        llm_config=MODEL_CONFIGS["llama"],
-        emotion="thoughtful and methodical"
-    )
-    return {
-        "model": "Llama 4 Scout",
-        "technique": "Emotion Prompting",
-        "response": response
-    }
+    url = f"{COINGECKO_API_BASE}/simple/price"
+    params = {"ids": coin_id, "vs_currencies": vs_currency, "include_market_cap": "true"}
+    resp = requests.get(url, params=params)
+    if resp.status_code == 200:
+        data = resp.json()
+        if coin_id in data:
+            return {
+                "coin": coin_id,
+                "currency": vs_currency,
+                "price": data[coin_id][vs_currency],
+                "market_cap": data[coin_id].get(f"{vs_currency}_market_cap"),
+            }
+        else:
+            return {"error": "Coin not found"}
+    else:
+        return {"error": f"Failed to fetch data ({resp.status_code})"}
 
-def proctor_mistral_tips(problem: str) -> dict:
+def get_market_info() -> dict:
     """
-    Fast Role Prompting with Mistral Small (for quick suggestions).
+    Get global cryptocurrency market information.
     """
-    technique = RolePrompting()
-    response = technique.execute(
-        problem,
-        llm_config=MODEL_CONFIGS["mistral"],
-        role="Construction Project Manager"
-    )
-    return {
-        "model": "Mistral Small 3.1 24B",
-        "technique": "Role Prompting",
-        "response": response
-    }
+    url = f"{COINGECKO_API_BASE}/global"
+    resp = requests.get(url)
+    if resp.status_code == 200:
+        data = resp.json()["data"]
+        return {
+            "active_cryptocurrencies": data["active_cryptocurrencies"],
+            "upcoming_icos": data["upcoming_icos"],
+            "ongoing_icos": data["ongoing_icos"],
+            "ended_icos": data["ended_icos"],
+            "markets": data["markets"],
+            "total_market_cap_usd": data["total_market_cap"]["usd"],
+            "market_cap_change_percentage_24h_usd": data["market_cap_change_percentage_24h_usd"],
+            "updated_at": data["updated_at"]
+        }
+    else:
+        return {"error": f"Failed to fetch data ({resp.status_code})"}
 
-# Optionally, expose a unified tool for arbitrary model/technique selection:
-def proctor_flexible(
-    problem: str,
-    model: str = "gemini",
-    technique: str = "ChainOfThought",
-    role: str = "",
-    emotion: str = ""
-) -> dict:
+def get_coin_history(coin_id: str = "bitcoin", date: str = "01-01-2023") -> dict:
     """
-    Flexible interface for any model/technique combo.
+    Get historical price data for a coin on a given date (dd-mm-yyyy).
+    Args:
+        coin_id (str): CoinGecko coin ID (e.g. 'bitcoin')
+        date (str): Date in format 'dd-mm-yyyy'
     """
-    technique_map = {
-        "ChainOfThought": ChainOfThought,
-        "RolePrompting": RolePrompting,
-        "EmotionPrompting": EmotionPrompting,
-        "SelfAsk": SelfAsk,
-        "ChainOfVerification": ChainOfVerification,
-    }
-    if technique == "CompositeExpert":
-        tech = CompositeTechnique(
-            name="Expert Chain-of-Thought",
-            identifier="custom-expert-cot",
-            techniques=[
-                RolePrompting(),
-                ChainOfThought(),
-                ChainOfVerification(),
-            ],
-        )
-        response = tech.execute(problem, llm_config=MODEL_CONFIGS[model], role=role)
-    elif technique == "DeepReasoning":
-        tech = CompositeTechnique(
-            name="Deep Reasoning Analysis",
-            identifier="deep-reasoning",
-            techniques=[
-                ChainOfThought(),
-                SelfAsk(),
-                ChainOfVerification(),
-            ],
-        )
-        response = tech.execute(problem, llm_config=MODEL_CONFIGS[model])
+    url = f"{COINGECKO_API_BASE}/coins/{coin_id}/history"
+    params = {"date": date}
+    resp = requests.get(url, params=params)
+    if resp.status_code == 200:
+        data = resp.json()
+        try:
+            price = data["market_data"]["current_price"]["usd"]
+        except Exception:
+            price = None
+        return {
+            "coin": coin_id,
+            "date": date,
+            "price_usd": price,
+            "snapshot": data.get("market_data", {})
+        }
     else:
-        tech_cls = technique_map.get(technique, ChainOfThought)
-        if technique == "RolePrompting":
-            response = tech_cls().execute(problem, llm_config=MODEL_CONFIGS[model], role=role)
-        elif technique == "EmotionPrompting":
-            response = tech_cls().execute(problem, llm_config=MODEL_CONFIGS[model], emotion=emotion)
-        else:
-            response = tech_cls().execute(problem, llm_config=MODEL_CONFIGS[model])
-    return {
-        "model": MODEL_CONFIGS[model]["model"],
-        "technique": technique,
-        "response": response
-    }
-
-# ----- Gradio/MCP Interface -----
+        return {"error": f"Failed to fetch data ({resp.status_code})"}
 
 with gr.Blocks() as demo:
-    gr.Markdown("# 🏗️ Proctor AI MCP Server\nAdvanced prompt engineering tools via OpenRouter and Proctor AI.\n\n*Try from an MCP-compatible client or the web UI below!*")
-    with gr.Tab("Gemini (Expert CoT)"):
-        gr.Interface(fn=proctor_expert_cot, inputs=gr.Textbox(label="Problem"), outputs=gr.JSON(), allow_flagging="never")
-    with gr.Tab("Claude 4 (Chain-of-Thought)"):
-        gr.Interface(fn=proctor_claude_cot, inputs=gr.Textbox(label="Problem"), outputs=gr.JSON(), allow_flagging="never")
-    with gr.Tab("DeepSeek R1 (Deep Reasoning)"):
-        gr.Interface(fn=proctor_deepseek_reasoning, inputs=gr.Textbox(label="Problem"), outputs=gr.JSON(), allow_flagging="never")
-    with gr.Tab("Llama 4 (Emotion Prompting)"):
-        gr.Interface(fn=proctor_llama_emotion, inputs=gr.Textbox(label="Problem"), outputs=gr.JSON(), allow_flagging="never")
-    with gr.Tab("Mistral (Quick Tips)"):
-        gr.Interface(fn=proctor_mistral_tips, inputs=gr.Textbox(label="Problem (tips request)"), outputs=gr.JSON(), allow_flagging="never")
-    with gr.Tab("Flexible (Advanced)"):
-        model_dropdown = gr.Dropdown(choices=list(MODEL_CONFIGS.keys()), value="gemini", label="Model")
-        technique_dropdown = gr.Dropdown(
-            choices=["ChainOfThought", "RolePrompting", "EmotionPrompting", "SelfAsk", "ChainOfVerification", "CompositeExpert", "DeepReasoning"],
-            value="ChainOfThought",
-            label="Technique"
+    gr.Markdown("# 🪙 CoinGecko MCP API\n\n**Live cryptocurrency data, globally accessible via Model Context Protocol (MCP)!**")
+    with gr.Tab("Get Current Price"):
+        gr.Interface(
+            fn=get_current_price,
+            inputs=[gr.Textbox(value="bitcoin", label="Coin ID (e.g. bitcoin, ethereum)"),
+                    gr.Textbox(value="usd", label="Fiat Currency (e.g. usd, eur)")],
+            outputs=gr.JSON(),
+            allow_flagging="never"
+        )
+    with gr.Tab("Global Market Info"):
+        gr.Interface(
+            fn=get_market_info,
+            inputs=[],
+            outputs=gr.JSON(),
+            allow_flagging="never"
         )
-        role_input = gr.Textbox(label="Role (optional)", value="")
-        emotion_input = gr.Textbox(label="Emotion (optional)", value="")
-        flexible_iface = gr.Interface(
-            fn=proctor_flexible,
-            inputs=[gr.Textbox(label="Problem"),
-                    model_dropdown,
-                    technique_dropdown,
-                    role_input,
-                    emotion_input],
+    with gr.Tab("Get Coin History"):
+        gr.Interface(
+            fn=get_coin_history,
+            inputs=[gr.Textbox(value="bitcoin", label="Coin ID"), gr.Textbox(value="01-01-2023", label="Date (dd-mm-yyyy)")],
             outputs=gr.JSON(),
             allow_flagging="never"
         )