test

app.py

@@ -1,145 +1,90 @@
+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 typing import Optional
 from contextlib import AsyncExitStack
 
-from mcp import ClientSession, StdioServerParameters
-from mcp.client.stdio import stdio_client
+cle_api = os.environ.get("CLE_API_MISTRAL")
 
-from anthropic import Anthropic
-import os
+# 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)
 
-class MCPClient:
+class MCPClientWrapper:
     def __init__(self):
-        # Initialize session and client objects
-        self.session: Optional[ClientSession] = None
+        self.session = None
+        self.exit_stack = None
+        self.tools = []
+    
+    def connect(self, server_path: str) -> str:
+        return loop.run_until_complete(self._connect(server_path))
+    
+    async def _connect(self, server_path: str) -> str:
+        if self.exit_stack:
+            await self.exit_stack.aclose()
+        
         self.exit_stack = AsyncExitStack()
-        self.anthropic = Anthropic(api_key=os.environ.get("CLE_API_ANTHROPIC"))
-
-    async def connect_to_server(self, server_script_path: str):
-        """Connect to an MCP server
         
-        Args:
-            server_script_path: Path to the server script (.py or .js)
-        """
-        is_python = server_script_path.endswith('.py')
-        is_js = server_script_path.endswith('.js')
-        if not (is_python or is_js):
-            raise ValueError("Server script must be a .py or .js file")
-            
+        is_python = server_path.endswith('.py')
         command = "python" if is_python else "node"
+        
         server_params = StdioServerParameters(
             command=command,
-            args=[server_script_path],
-            env=None
+            args=[server_path],
+            env={"PYTHONIOENCODING": "utf-8", "PYTHONUNBUFFERED": "1"}
         )
         
         stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server_params))
         self.stdio, self.write = stdio_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.stdio, self.write))
         await self.session.initialize()
         
-        # List available tools
         response = await self.session.list_tools()
-        tools = response.tools
-        print("\nConnected to server with tools:", [tool.name for tool in tools])
-
-    async def process_query(self, query: str) -> str:
-        """Process a query using Claude and available tools"""
-        messages = [
-            {
-                "role": "user",
-                "content": query
-            }
-        ]
-
-        response = await self.session.list_tools()
-        available_tools = [{ 
+        self.tools = [{ 
             "name": tool.name,
             "description": tool.description,
             "input_schema": tool.inputSchema
         } for tool in response.tools]
-
-        # Initial Claude API call
-        response = self.anthropic.messages.create(
-            model="claude-3-5-sonnet-20241022",
-            max_tokens=1000,
-            messages=messages,
-            tools=available_tools
-        )
-
-        # Process response and handle tool calls
-        tool_results = []
-        final_text = []
-
-        for content in response.content:
-            if content.type == 'text':
-                final_text.append(content.text)
-            elif content.type == 'tool_use':
-                tool_name = content.name
-                tool_args = content.input
-                
-                # Execute tool call
-                result = await self.session.call_tool(tool_name, tool_args)
-                tool_results.append({"call": tool_name, "result": result})
-                final_text.append(f"[Calling tool {tool_name} with args {tool_args}]")
-
-                # Continue conversation with tool results
-                if hasattr(content, 'text') and content.text:
-                    messages.append({
-                      "role": "assistant",
-                      "content": content.text
-                    })
-                messages.append({
-                    "role": "user", 
-                    "content": result.content
-                })
-
-                # Get next response from Claude
-                response = self.anthropic.messages.create(
-                    model="claude-3-5-sonnet-20241022",
-                    max_tokens=1000,
-                    messages=messages,
-                )
-
-                final_text.append(response.content[0].text)
-
-        return "\n".join(final_text)
-
-    async def chat_loop(self):
-        """Run an interactive chat loop"""
-        print("\nMCP Client Started!")
-        print("Type your queries or 'quit' to exit.")
         
-        while True:
-            try:
-                query = input("\nQuery: ").strip()
-                
-                if query.lower() == 'quit':
-                    break
-                    
-                response = await self.process_query(query)
-                print("\n" + response)
-                    
-            except Exception as e:
-                print(f"\nError: {str(e)}")
+        tool_names = [tool["name"] for tool in self.tools]
+        return f"Connected to MCP server. Available tools: {', '.join(tool_names)}"
+
+clientMCP = MCPClientWrapper()
+clientMCP.connect("mcp_server.py")
+print(clientMCP.tools)
+
+# Chatbot : simple écho Fonction chatbot reliée à Mistral
+def chatbot(message, history):
+    # Préparer l’historique dans le format de Mistral
+    messages = []
+    for user_msg, bot_msg in history:
+        messages.append({"role": "user", "content": user_msg})
+        messages.append({"role": "assistant", "content": bot_msg})
     
-    async def cleanup(self):
-        """Clean up resources"""
-        await self.exit_stack.aclose()
+    messages.append({"role": "user", "content": message})
+
+    # Appel API Mistral
+    response = clientLLM.chat.completions.create(
+        model="mistral-small-latest", 
+        messages=messages,
+        tools=clientMCP.tools
+    )
+
+    bot_reply = response.choices[0].message.content.strip()
+    history.append(("Vous: " + message, "Bot: " + bot_reply))
+    return history, history
+    
+with gr.Blocks() as demo:
 
-async def main():
-    if len(sys.argv) < 2:
-        print("Usage: python client.py mcp_server.py")
-        sys.exit(1)
-        
-    client = MCPClient()
-    try:
-        await client.connect_to_server(sys.argv[1])
-        await client.chat_loop()
-    finally:
-        await client.cleanup()
+    chatbot_ui = gr.Chatbot(label="ChatBot")
+    msg = gr.Textbox(placeholder="Écrivez un message...")
+
+    msg.submit(chatbot, [msg, chatbot_ui], [chatbot_ui, chatbot_ui])
 
-if __name__ == "__main__":
-    import sys
-    asyncio.run(main())
+demo.launch(debug=True)