test

app.py

@@ -1,17 +1,16 @@
 import gradio as gr
 from openai import OpenAI
 import os
-from mcp import ClientSession, StdioServerParameters
-from mcp.client.stdio import stdio_client
 import asyncio
 from contextlib import AsyncExitStack
+from mcp import ClientSession, HttpServerParameters
+from mcp.client.http import http_client
 
 cle_api = os.environ.get("CLE_API_MISTRAL")
 
 # Initialisation du client Mistral (API compatible OpenAI)
 clientLLM = OpenAI(api_key=cle_api, base_url="https://api.mistral.ai/v1")
 
-
 loop = asyncio.new_event_loop()
 asyncio.set_event_loop(loop)
 
@@ -21,28 +20,22 @@ class MCPClientWrapper:
         self.exit_stack = None
         self.tools = []
     
-    def connect(self, server_path: str) -> str:
-        return loop.run_until_complete(self._connect(server_path))
+    def connect(self, server_url: str) -> str:
+        return loop.run_until_complete(self._connect(server_url))
     
-    async def _connect(self, server_path: str) -> str:
+    async def _connect(self, server_url: str) -> str:
         if self.exit_stack:
             await self.exit_stack.aclose()
         
         self.exit_stack = AsyncExitStack()
         
-        is_python = server_path.endswith('.py')
-        command = "python" if is_python else "node"
-        
-        server_params = StdioServerParameters(
-            command=command,
-            args=[server_path],
-            env={"PYTHONIOENCODING": "utf-8", "PYTHONUNBUFFERED": "1"}
-        )
+        # Paramètres HTTP MCP
+        server_params = HttpServerParameters(url=server_url)
         
-        stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server_params))
-        self.stdio, self.write = stdio_transport
+        http_transport = await self.exit_stack.enter_async_context(http_client(server_params))
+        self.http, self.write = http_transport
         
-        self.session = await self.exit_stack.enter_async_context(ClientSession(self.stdio, self.write))
+        self.session = await self.exit_stack.enter_async_context(ClientSession(self.http, self.write))
         await self.session.initialize()
         
         response = await self.session.list_tools()
@@ -53,15 +46,17 @@ class MCPClientWrapper:
         } for tool in response.tools]
         
         tool_names = [tool["name"] for tool in self.tools]
-        return f"Connected to MCP server. Available tools: {', '.join(tool_names)}"
+        return f"Connecté au MCP {server_url}. Outils disponibles : {', '.join(tool_names)}"
 
+# Connexion au MCP HuggingFace
 clientMCP = MCPClientWrapper()
-clientMCP.connect("mcp_server.py")
+print(clientMCP.connect("https://huggingface.co/spaces/HackathonCRA/mcp"))
 print(clientMCP.tools)
 
-# Chatbot : simple écho Fonction chatbot reliée à Mistral
+
+# Chatbot
 def chatbot(message, history):
-    # Préparer l’historique dans le format de Mistral
+    # Préparer l’historique
     messages = []
     for user_msg, bot_msg in history:
         messages.append({"role": "user", "content": user_msg})
@@ -73,54 +68,7 @@ def chatbot(message, history):
     response = clientLLM.chat.completions.create(
         model="mistral-small-latest", 
         messages=messages,
-        tools=[
-            {
-                "type": "function",
-                "function": {
-                    "name": "analyze_herbicide_trends",
-                    "description": "Analyze herbicide usage trends over time.",
-                    "parameters": {
-                        "type": "object",
-                        "properties": {
-                            "years_range": {"type": "string"},
-                            "plot_filter": {"type": "string"}
-                        },
-                        "required": ["years_range", "plot_filter"]
-                    }
-                }
-            },
-            {
-                "type": "function",
-                "function": {
-                    "name": "predict_future_weed_pressure",
-                    "description": "Predict weed pressure for the next 3 years.",
-                    "parameters": {"type": "object", "properties": {}}
-                }
-            },
-            {
-                "type": "function",
-                "function": {
-                    "name": "recommend_sensitive_crop_plots",
-                    "description": "Recommend plots for sensitive crops.",
-                    "parameters": {"type": "object", "properties": {}}
-                }
-            },
-            {
-                "type": "function",
-                "function": {
-                    "name": "generate_technical_alternatives",
-                    "description": "Generate technical alternatives.",
-                    "parameters": {
-                        "type": "object",
-                        "properties": {
-                            "herbicide_family": {"type": "string"}
-                        },
-                        "required": ["herbicide_family"]
-                    }
-                }
-            }
-        ]
-
+        tools=clientMCP.tools  # ��� maintenant on injecte directement les tools MCP récupérés
     )
 
     bot_reply = response.choices[0].message.content.strip()
@@ -128,10 +76,9 @@ def chatbot(message, history):
     return history, history
     
 with gr.Blocks() as demo:
-
     chatbot_ui = gr.Chatbot(label="ChatBot")
     msg = gr.Textbox(placeholder="Écrivez un message...")
 
     msg.submit(chatbot, [msg, chatbot_ui], [chatbot_ui, chatbot_ui])
 
-demo.launch(debug=True)
+demo.launch(debug=True)