Feat: Mistral Async Client

Author: lambda-science

Dockerfile

@@ -12,12 +12,13 @@ RUN apt update && \
     git \
     && rm -rf /var/lib/apt/lists/*
 
-WORKDIR /app
-COPY README.md /app/
-COPY pyproject.toml /app/
-RUN uv sync --no-install-project --no-dev
-COPY src/opensymbiose /app/opensymbiose
+WORKDIR /src
+COPY README.md /src/
+COPY pyproject.toml /src/
+RUN uv sync --no-dev
+COPY src/opensymbiose /src/opensymbiose
 
-EXPOSE 8000
+EXPOSE 7860
 
-CMD ["uv", "run", "opensymbiose/main.py"]
+ENV PYTHONPATH=/src
+CMD ["uv", "run", "gradio", "/src/opensymbiose/gradio/app.py"]

Makefile

@@ -53,10 +53,10 @@ dockerbuild:
 	docker build -t opensymbiose:latest .
 
 dockerrun:
-	docker run --rm opensymbiose:latest
+	docker run --rm -p 7860:7860 --env-file .env opensymbiose:latest
 
 allci:
 	$(MAKE) check
 	$(MAKE) format
 	$(MAKE) type
-	$(MAKE) cov
+	$(MAKE) cov

README.md

@@ -3,18 +3,25 @@ title: opensymbiose
 app_file: src/opensymbiose/gradio/app.py
 sdk: gradio
 sdk_version: 5.31.0
+python_version: 3.13
 ---
 # OpenSymbiose: Open Source Biotechnology AI Agent
 
-OpenSymbiose is an open-source biotechnology / biology research AI agent designed to support researcher.
+OpenSymbiose is an open-source biotechnology / biology research AI agent designed to support researchers.
 
 [DOCUMENTATION](https://lambda-science.github.io/OpenSymbiose/) - [DEMO ON HUGGINGFACE](https://huggingface.co/spaces/corentinm7/opensymbiose) - [CODE REPO](https://github.com/lambda-science/OpenSymbiose)
 
 Creator and Maintainer: [**Corentin Meyer**, PhD](https://cmeyer.fr/) - <contact@cmeyer.fr>
 
 ## Installation
 
-From PyPi: `pip install opensymbiose`
+If you want just to interact with it, an online demo is available
+on [HuggingFace](https://huggingface.co/spaces/corentinm7/opensymbiose)
+
+**Note:** In every-case you will need an environment variable or a .env file with your `MISTRAL_API_KEY` secret.
+
+- Install from PyPi: `pip install opensymbiose` and run in your terminal `opensymbiose` it will boot the gradio app.
+- From GitHub: clone the repository and run `make dev`. It will launch the Gradio app with hot-reloading.
 
 ## Usage
 

src/opensymbiose/agents/__init__.py

@@ -8,4 +8,4 @@
 from opensymbiose.agents.agent_manager import AgentManager
 from opensymbiose.agents.create_agents import setup_agents, get_agents
 
-__all__ = ['Agent', 'AgentManager', 'setup_agents', 'get_agents']
+__all__ = ["Agent", "AgentManager", "setup_agents", "get_agents"]

src/opensymbiose/agents/agent.py

@@ -1,6 +1,7 @@
 """
 Agent class to represent individual Mistral AI agents.
 """
+
 from typing import Any
 
 from mistralai import Mistral
@@ -14,7 +15,7 @@ class Agent:
     def __init__(self, agent_data: Any):
         """
         Initialize an Agent object from Mistral API agent data.
-        
+
         Args:
             agent_data: The agent data returned from Mistral API
         """
@@ -23,57 +24,55 @@ def __init__(self, agent_data: Any):
         self.description = agent_data.description
         self.model = agent_data.model
         self.tools = agent_data.tools
-        self.handoffs = agent_data.handoffs if hasattr(agent_data, 'handoffs') else []
+        self.handoffs = agent_data.handoffs if hasattr(agent_data, "handoffs") else []
         self._raw_data = agent_data
 
     @property
     def raw_data(self) -> Any:
         """
         Get the raw agent data from Mistral API.
-        
+
         Returns:
             The raw agent data
         """
         return self._raw_data
 
-    def add_handoff(self, agent_id: str, client: Mistral) -> None:
+    async def add_handoff(self, agent_id: str, client: Mistral) -> None:
         """
         Add a handoff to another agent.
-        
+
         Args:
             agent_id: The ID of the agent to handoff to
             client: The Mistral client instance
         """
         if agent_id not in self.handoffs:
             self.handoffs.append(agent_id)
-            updated_agent = client.beta.agents.update(
-                agent_id=self.id,
-                handoffs=self.handoffs
+            updated_agent = client.beta.agents.update_async(
+                agent_id=self.id, handoffs=self.handoffs
             )
             # Update the raw data with the updated agent
             self._raw_data = updated_agent
 
-    def remove_handoff(self, agent_id: str, client: Mistral) -> None:
+    async def remove_handoff(self, agent_id: str, client: Mistral) -> None:
         """
         Remove a handoff to another agent.
-        
+
         Args:
             agent_id: The ID of the agent to remove handoff from
             client: The Mistral client instance
         """
         if agent_id in self.handoffs:
             self.handoffs.remove(agent_id)
-            updated_agent = client.beta.agents.update(
-                agent_id=self.id,
-                handoffs=self.handoffs
+            updated_agent = client.beta.agents.update_async(
+                agent_id=self.id, handoffs=self.handoffs
             )
             # Update the raw data with the updated agent
             self._raw_data = updated_agent
 
     def __str__(self) -> str:
         """
         String representation of the agent.
-        
+
         Returns:
             A string representation of the agent
         """
@@ -82,10 +81,12 @@ def __str__(self) -> str:
     def __repr__(self) -> str:
         """
         Detailed representation of the agent.
-        
+
         Returns:
             A detailed representation of the agent
         """
-        return (f"Agent(id={self.id}, name={self.name}, "
-                f"description={self.description}, model={self.model}, "
-                f"tools={self.tools}, handoffs={self.handoffs})")
+        return (
+            f"Agent(id={self.id}, name={self.name}, "
+            f"description={self.description}, model={self.model}, "
+            f"tools={self.tools}, handoffs={self.handoffs})"
+        )

src/opensymbiose/agents/agent_manager.py

@@ -1,6 +1,7 @@
 """
 AgentManager class to manage Mistral AI agents.
 """
+
 import os
 from typing import Dict, List, Optional
 
@@ -20,10 +21,10 @@ class AgentManager:
     def __new__(cls, api_key: Optional[str] = None):
         """
         Create a new instance of AgentManager or return the existing one (Singleton pattern).
-        
+
         Args:
             api_key: The Mistral API key. If not provided, it will be read from the environment.
-        
+
         Returns:
             The AgentManager instance
         """
@@ -35,7 +36,7 @@ def __new__(cls, api_key: Optional[str] = None):
     def __init__(self, api_key: Optional[str] = None):
         """
         Initialize the AgentManager with the Mistral API key.
-        
+
         Args:
             api_key: The Mistral API key. If not provided, it will be read from the environment.
         """
@@ -46,81 +47,75 @@ def __init__(self, api_key: Optional[str] = None):
         self.api_key = api_key or os.environ.get("MISTRAL_API_KEY")
         if not self.api_key:
             raise ValueError(
-                "Mistral API key is required. Provide it as an argument or set the MISTRAL_API_KEY environment variable.")
+                "Mistral API key is required. Provide it as an argument or set the MISTRAL_API_KEY environment variable."
+            )
 
         self.client = Mistral(self.api_key)
         self.agents: Dict[str, Agent] = {}
         self._initialized = True
 
-    def list_agents(self) -> List[Agent]:
+    async def list_agents(self) -> List[Agent]:
         """
         List all agents from the Mistral API.
-        
+
         Returns:
             A list of Agent objects
         """
-        agent_list = self.client.beta.agents.list()
+        agent_list = await self.client.beta.agents.list_async()
         return [Agent(agent) for agent in agent_list]
 
-    def refresh_agents(self) -> None:
+    async def refresh_agents(self) -> None:
         """
         Refresh the local cache of agents from the Mistral API.
         """
         self.agents = {}
-        agent_list = self.client.beta.agents.list()
+        agent_list = await self.client.beta.agents.list_async()
         for agent_data in agent_list:
             agent = Agent(agent_data)
             self.agents[agent.name] = agent
 
-    def get_agent(self, agent_name: str) -> Optional[Agent]:
+    async def get_agent(self, agent_name: str) -> Optional[Agent]:
         """
         Get an agent by name.
-        
+
         Args:
             agent_name: The name of the agent
-            
+
         Returns:
             The Agent object if found, None otherwise
         """
         # Refresh agents if not already loaded
         if not self.agents:
-            self.refresh_agents()
+            await self.refresh_agents()
 
         return self.agents.get(agent_name)
 
-    def get_or_create_agent(
-            self,
-            agent_name: str,
-            model: str,
-            description: str,
-            tools: List[Dict[str, str]]
+    async def get_or_create_agent(
+            self, agent_name: str, model: str, description: str, tools: List[Dict[str, str]]
     ) -> Agent:
         """
         Get an agent by name or create it if it doesn't exist.
-        
+
         Args:
             agent_name: The name of the agent
             model: The model to use for the agent
             description: The description of the agent
             tools: The tools to enable for the agent
-            
+
         Returns:
             The Agent object
         """
         # Refresh agents if not already loaded
         if not self.agents:
-            self.refresh_agents()
+            await self.refresh_agents()
 
         # Check if agent exists
         agent = self.agents.get(agent_name)
 
         # Create agent if it doesn't exist
         if not agent:
-            agent_data = self.client.beta.agents.create(
-                model=model,
-                description=description,
-                name=agent_name,
-                tools=tools
+            agent_data = await self.client.beta.agents.create_async(
+                model=model, description=description, name=agent_name, tools=tools
             )
             agent = Agent(agent_data)
             self.agents[agent_name] = agent
@@ -130,23 +125,23 @@ def get_or_create_agent(
 
         return agent
 
-    def create_handoff(self, from_agent_name: str, to_agent_name: str) -> None:
+    async def create_handoff(self, from_agent_name: str, to_agent_name: str) -> None:
         """
         Create a handoff from one agent to another.
-        
+
         Args:
             from_agent_name: The name of the agent to handoff from
             to_agent_name: The name of the agent to handoff to
         """
-        from_agent = self.get_agent(from_agent_name)
-        to_agent = self.get_agent(to_agent_name)
+        from_agent = await self.get_agent(from_agent_name)
+        to_agent = await self.get_agent(to_agent_name)
 
         if not from_agent:
             raise ValueError(f"Agent '{from_agent_name}' not found")
         if not to_agent:
             raise ValueError(f"Agent '{to_agent_name}' not found")
 
-        from_agent.add_handoff(to_agent.id, self.client)
+        await from_agent.add_handoff(to_agent.id, self.client)
 
         # Update the local cache
         self.agents[from_agent_name] = from_agent

src/opensymbiose/agents/create_agents.py

@@ -2,10 +2,11 @@
 Module for creating and managing Mistral AI agents.
 This module provides a simple interface to create and manage agents using the AgentManager class.
 """
+
 from opensymbiose.agents.agent_manager import AgentManager
 
 
-def setup_agents():
+async def setup_agents():
     """
     Set up the agents for the application.
 
@@ -16,41 +17,39 @@ def setup_agents():
     agent_manager = AgentManager()
 
     # Get or create the test agent with web search tool
-    test_agent = agent_manager.get_or_create_agent(
+    test_agent = await agent_manager.get_or_create_agent(
         agent_name="Test Agent Tools",
         model="mistral-medium-latest",
         description="An agent with tools",
-        tools=[{"type": "web_search"}]
+        tools=[{"type": "web_search"}],
     )
 
     # Get or create the calculating agent with code interpreter tool
-    calculating_agent = agent_manager.get_or_create_agent(
+    calculating_agent = await agent_manager.get_or_create_agent(
         agent_name="Calculating Agent",
         model="mistral-medium-latest",
         description="A calculating agent with tools",
-        tools=[{"type": "code_interpreter"}]
+        tools=[{"type": "code_interpreter"}],
     )
 
     # Create handoff from test agent to calculating agent
-    agent_manager.create_handoff("Test Agent Tools", "Calculating Agent")
+    await agent_manager.create_handoff("Test Agent Tools", "Calculating Agent")
 
     # Return a dictionary of agent names to Agent objects
-    return {
-        "test_agent_tools": test_agent,
-        "calculating_agent": calculating_agent
-    }
+    return {"test_agent_tools": test_agent, "calculating_agent": calculating_agent}
 
 
 # Create a convenience function to get the agents
-def get_agents():
+async def get_agents():
     """
     Get the agents for the application.
 
     Returns:
         A dictionary of agent names to Agent objects
     """
-    return setup_agents()
+    return await setup_agents()
 
 
 # For backwards compatibility and direct script execution
-symbiose_agents = setup_agents() if __name__ == "__main__" else {}
+# Note: This is now just a placeholder as setup_agents() is async and can't be awaited at module level
+symbiose_agents = {}