Upload folder using huggingface_hub

CHANGELOG.md

@@ -1,5 +1,8 @@
-# v0.0.2
+# v0.0.3
+
+- Async Query of Mistral API
 
+# v0.0.2
 - More lax python version for HuggingFace Space
 
 # v0.0.1

Dockerfile

@@ -12,12 +12,14 @@ 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
+ENV GRADIO_SERVER_NAME=0.0.0.0
+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

@@ -7,7 +7,7 @@ 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)
 
@@ -15,9 +15,12 @@ Creator and Maintainer: [**Corentin Meyer**, PhD](https://cmeyer.fr/) - <contact
 
 ## 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)
 
-## Usage
-
-Placeholder
+**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`
+    - Locally: Run in your terminal `opensymbiose` it will boot the gradio app
+    - In Docker: `make dockerbuild && make dockerrun` to run in Docker.
+- From GitHub: clone the repository and run `make dev`. It will launch the Gradio app with hot-reloading.

docs/index.md

@@ -7,14 +7,20 @@ hide:
 
 # 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/) - <[email protected]>
 
 ## 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)
 
-## Usage
+**Note:** In every-case you will need an environment variable or a .env file with your `MISTRAL_API_KEY` secret.
 
-Placeholder
+- Install from PyPi: `pip install opensymbiose`
+    - Locally: Run in your terminal `opensymbiose` it will boot the gradio app
+    - In Docker: `make dockerbuild && make dockerrun` to run in Docker.
+- From GitHub: clone the repository and run `make dev`. It will launch the Gradio app with hot-reloading.

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "opensymbiose"
-version = "0.0.2"
+version = "0.0.3"
 description = "OpenSymbiose is an open-source biotechnology / biology research AI agent designed to support researcher."
 readme = "README.md"
 requires-python = ">=3.10"

src/opensymbiose/agents/__init__.py

@@ -8,4 +8,4 @@ from opensymbiose.agents.agent import Agent
 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,49 +24,47 @@ class Agent:
         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
@@ -73,7 +72,7 @@ class Agent:
     def __str__(self) -> str:
         """
         String representation of the agent.
-        
+
         Returns:
             A string representation of the agent
         """
@@ -82,10 +81,12 @@ class Agent:
     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 @@ class AgentManager:
     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 @@ class AgentManager:
         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 @@ class AgentManager:
 
         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 = {}

src/opensymbiose/agents/test_agent_manager.py

@@ -1,11 +1,13 @@
 """
 Test script for the AgentManager and Agent classes.
 """
+
+import asyncio
 import os
 import sys
 
 # Add the parent directory to the path to allow importing the modules
-sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '../../..')))
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../../..")))
 
 from opensymbiose.agents.agent_manager import AgentManager
 from opensymbiose.agents.create_agents import setup_agents, get_agents
@@ -40,22 +42,24 @@ def test_agent_manager():
     print("AgentManager tests completed successfully")
 
 
-def test_create_agents():
+async def test_create_agents():
     """
     Test the create_agents module.
     """
     print("\nTesting create_agents module...")
 
     # Test setup_agents function
-    agents = setup_agents()
+    agents = await setup_agents()
     assert "test_agent_tools" in agents, "Test agent not created"
     assert "calculating_agent" in agents, "Calculating agent not created"
 
     print(f"✓ setup_agents created {len(agents)} agents")
 
     # Test get_agents function
-    agents2 = get_agents()
-    assert agents2["test_agent_tools"].id == agents["test_agent_tools"].id, "get_agents returned different agents"
+    agents2 = await get_agents()
+    assert agents2["test_agent_tools"].id == agents["test_agent_tools"].id, (
+        "get_agents returned different agents"
+    )
 
     print("✓ get_agents works correctly")
 
@@ -70,7 +74,8 @@ def test_create_agents():
     print("create_agents tests completed successfully")
 
 
-if __name__ == "__main__":
+async def main():
+    """Run all tests."""
     # Check if MISTRAL_API_KEY is set
     if not os.environ.get("MISTRAL_API_KEY"):
         print("Error: MISTRAL_API_KEY environment variable is not set")
@@ -78,6 +83,10 @@ if __name__ == "__main__":
         sys.exit(1)
 
     test_agent_manager()
-    test_create_agents()
+    await test_create_agents()
 
     print("\nAll tests completed successfully!")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

src/opensymbiose/gradio/app.py

@@ -12,8 +12,8 @@ from opensymbiose.agents.create_agents import get_agents
 
 logging.basicConfig(
     level=logging.WARNING,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[logging.StreamHandler()]
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    handlers=[logging.StreamHandler()],
 )
 logger = logging.getLogger(__name__)
 client = Mistral(api_key=opensymbiose.config.MISTRAL_API_KEY)
@@ -23,7 +23,8 @@ model = "mistral-medium-latest"
 logger.info(f"Gradio version: {gr.__version__}")
 logger.info(f"Python version: {sys.version}")
 
-def get_mistral_answer(message: str, history = None):
+
+async def get_mistral_answer(message: str, history=None):
     # Start global execution timer
     global_start_time = time.time()
     logger.info(f"Processing message: {message}")
@@ -31,73 +32,140 @@ def get_mistral_answer(message: str, history = None):
     # Dictionary to track tool execution times
     tool_timers = {}
 
-    agents = get_agents()
+    agents = await get_agents()
     main_agent = agents["test_agent_tools"]
-    stream_response = client.beta.conversations.start_stream(
+    stream_response = await client.beta.conversations.start_stream_async(
         agent_id=main_agent.id, inputs=message, store=False
     )
     messages = []
     # Add an initial empty message for the assistant's response
     messages.append(asdict(ChatMessage(role="assistant", content="")))
-    yield messages
     full_response = ""
-    for chunk in stream_response:
+    async for chunk in stream_response:
         logger.info(f"Chunk: {chunk}")
         if chunk.event == "message.output.delta":
-            if isinstance(chunk.data.content, dict) and "filepath" in chunk.data.content:
+            if (
+                    isinstance(chunk.data.content, dict)
+                    and "filepath" in chunk.data.content
+            ):
                 # Handle file messages with proper alt_text
                 file_path = chunk.data.content["filepath"]
-                alt_text = chunk.data.content.get("alt_text", "File attachment")  # Default alt_text if not provided
-                messages.append(asdict(ChatMessage(role="assistant", content=file_path, 
-                                                 metadata={"type": "file", "alt_text": alt_text})))
+                alt_text = chunk.data.content.get(
+                    "alt_text", "File attachment"
+                )  # Default alt_text if not provided
+                messages.append(
+                    asdict(
+                        ChatMessage(
+                            role="assistant",
+                            content=file_path,
+                            metadata={"type": "file", "alt_text": alt_text},
+                        )
+                    )
+                )
             elif isinstance(chunk.data.content, str):
                 full_response += chunk.data.content
-                if messages and messages[-1].get("role") == "assistant" and not messages[-1].get("metadata"):
-                    messages[-1] = asdict(ChatMessage(role="assistant", content=full_response))
+                if (
+                        messages
+                        and messages[-1].get("role") == "assistant"
+                        and not messages[-1].get("metadata")
+                ):
+                    messages[-1] = asdict(
+                        ChatMessage(role="assistant", content=full_response)
+                    )
                 else:
-                    messages.append(asdict(ChatMessage(role="assistant", content=full_response)))
+                    messages.append(
+                        asdict(ChatMessage(role="assistant", content=full_response))
+                    )
             elif isinstance(chunk.data.content, ToolReferenceChunk):
-                full_response += f"([{chunk.data.content.title}]({chunk.data.content.url})) "
-                if messages and messages[-1].get("role") == "assistant" and not messages[-1].get("metadata"):
-                    messages[-1] = asdict(ChatMessage(role="assistant", content=full_response))
+                full_response += (
+                    f"([{chunk.data.content.title}]({chunk.data.content.url})) "
+                )
+                if (
+                        messages
+                        and messages[-1].get("role") == "assistant"
+                        and not messages[-1].get("metadata")
+                ):
+                    messages[-1] = asdict(
+                        ChatMessage(role="assistant", content=full_response)
+                    )
                 else:
-                    messages.append(asdict(ChatMessage(role="assistant", content=full_response)))
+                    messages.append(
+                        asdict(ChatMessage(role="assistant", content=full_response))
+                    )
             yield messages
         elif chunk.event == "tool.execution.started":
             # Start timer for this tool
             tool_timers[chunk.data.name] = time.time()
             # Add a new message for tool execution start
-            messages.append(asdict(ChatMessage(role="assistant", content="",
-                                               metadata={"title": f"🛠️ Using tool {chunk.data.name}..."})))
+            messages.append(
+                asdict(
+                    ChatMessage(
+                        role="assistant",
+                        content="",
+                        metadata={"title": f"🛠️ Using tool {chunk.data.name}..."},
+                    )
+                )
+            )
             yield messages
         elif chunk.event == "tool.execution.done":
             # Calculate tool execution duration
             tool_duration = time.time() - tool_timers.get(chunk.data.name, time.time())
             # Add a new message for tool execution completion
-            messages.append(asdict(ChatMessage(role="assistant", content="",
-                                               metadata={"title": f"🛠️ Finished using {chunk.data.name}.",
-                                                         "duration": round(tool_duration, 2)})))
+            messages.append(
+                asdict(
+                    ChatMessage(
+                        role="assistant",
+                        content="",
+                        metadata={
+                            "title": f"🛠️ Finished using {chunk.data.name}.",
+                            "duration": round(tool_duration, 2),
+                        },
+                    )
+                )
+            )
             # Add a new empty message for the continuing assistant response
-            messages.append(asdict(ChatMessage(role="assistant", content=full_response)))
+            messages.append(
+                asdict(ChatMessage(role="assistant", content=full_response))
+            )
             yield messages
         elif chunk.event == "agent.handoff.started":
             # Start timer for agent handoff
             tool_timers["agent_handoff"] = time.time()
             # Add a new message for agent handoff start
-            messages.append(asdict(ChatMessage(role="assistant", content="",
-                                               metadata={
-                                                   "title": f"🔄 Handing off from agent {chunk.data.previous_agent_name}..."})))
+            messages.append(
+                asdict(
+                    ChatMessage(
+                        role="assistant",
+                        content="",
+                        metadata={
+                            "title": f"🔄 Handing off from agent {chunk.data.previous_agent_name}..."
+                        },
+                    )
+                )
+            )
             yield messages
         elif chunk.event == "agent.handoff.done":
             # Calculate handoff duration
-            handoff_duration = time.time() - tool_timers.get("agent_handoff", time.time())
+            handoff_duration = time.time() - tool_timers.get(
+                "agent_handoff", time.time()
+            )
             # Add a new message for agent handoff completion
-            messages.append(asdict(ChatMessage(role="assistant", content="",
-                                               metadata={
-                                                   "title": f"✅ Handoff complete. Now using agent {chunk.data.next_agent_name}.",
-                                                   "duration": round(handoff_duration, 2)})))
+            messages.append(
+                asdict(
+                    ChatMessage(
+                        role="assistant",
+                        content="",
+                        metadata={
+                            "title": f"✅ Handoff complete. Now using agent {chunk.data.next_agent_name}.",
+                            "duration": round(handoff_duration, 2),
+                        },
+                    )
+                )
+            )
             # Add a new empty message for the continuing assistant response
-            messages.append(asdict(ChatMessage(role="assistant", content=full_response)))
+            messages.append(
+                asdict(ChatMessage(role="assistant", content=full_response))
+            )
             yield messages
         elif chunk.event == "function.call.delta":
             # Start timer for function call
@@ -106,32 +174,66 @@ def get_mistral_answer(message: str, history = None):
             function_info = f"Calling function: {chunk.data.name} with arguments: {chunk.data.arguments}"
             # Store the function name for potential future duration calculation
             tool_timers[f"function_{chunk.data.name}"] = function_start_time
-            messages.append(asdict(ChatMessage(role="assistant", content="",
-                                               metadata={"title": f"📞 {function_info}"})))
+            messages.append(
+                asdict(
+                    ChatMessage(
+                        role="assistant",
+                        content="",
+                        metadata={"title": f"📞 {function_info}"},
+                    )
+                )
+            )
             yield messages
         elif chunk.event == "conversation.response.started":
             # Add a new message for conversation response start
-            messages.append(asdict(ChatMessage(role="assistant", content="",
-                                               metadata={"title": f"🚀 Symbiose agent is starting...",
-                                                         "log": f"{chunk.data.conversation_id}"})))
+            messages.append(
+                asdict(
+                    ChatMessage(
+                        role="assistant",
+                        content="",
+                        metadata={
+                            "title": "🚀 Symbiose agent is starting...",
+                            "log": f"{chunk.data.conversation_id}",
+                        },
+                    )
+                )
+            )
             yield messages
         elif chunk.event == "conversation.response.done":
             # Calculate global execution duration
             global_duration = time.time() - global_start_time
             # Add a new message for conversation response completion
-            messages.append(asdict(ChatMessage(role="assistant", content="",
-                                               metadata={"title": f"✅ Conversation response complete.",
-                                                         "log": f"Tokens: Prompt: {chunk.data.usage.prompt_tokens}, Completion: {chunk.data.usage.completion_tokens}, Total: {chunk.data.usage.total_tokens} Connectors: {chunk.data.usage.connector_tokens}",
-                                                         "duration": round(global_duration, 2)})))
-            logger.info(f"Conversation response complete. Duration: {round(global_duration, 2)}s, Total tokens: {chunk.data.usage.total_tokens}")
+            messages.append(
+                asdict(
+                    ChatMessage(
+                        role="assistant",
+                        content="",
+                        metadata={
+                            "title": "✅ Conversation response complete.",
+                            "log": f"Tokens: Prompt: {chunk.data.usage.prompt_tokens}, Completion: {chunk.data.usage.completion_tokens}, Total: {chunk.data.usage.total_tokens} Connectors: {chunk.data.usage.connector_tokens}",
+                            "duration": round(global_duration, 2),
+                        },
+                    )
+                )
+            )
+            logger.info(
+                f"Conversation response complete. Duration: {round(global_duration, 2)}s, Total tokens: {chunk.data.usage.total_tokens}"
+            )
             yield messages
         elif chunk.event == "conversation.response.error":
             # Add a new message for conversation response error
             error_message = f"Error: {chunk.data.message} (Code: {chunk.data.code})"
             logger.error(f"Conversation response error: {error_message}")
             logger.error(f"Chunk: {chunk}")
-            messages.append(asdict(ChatMessage(role="assistant", content="",
-                                               metadata={"title": f"❌ {error_message}"})))
+            messages.append(
+                asdict(
+                    ChatMessage(
+                        role="assistant",
+                        content="",
+                        metadata={"title": f"❌ {error_message}"},
+                    )
+                )
+            )
             yield messages
         else:
             # For other events, just update the last message
@@ -145,13 +247,17 @@ with gr.Blocks() as demo:
         type="messages",
         title="Open-Symbiose🧬",
         description="OpenSymbiose is an open-source biotechnology / biology research AI agent designed to support researcher",
-        examples=["search internet: CEO of google", "Use your calculator agent to do 1273*3/12^2"],
+        examples=[
+            "search internet: CEO of google",
+            "Use your calculator agent to do 1273*3/12^2",
+        ],
         save_history=True,
         flagging_mode="manual",
-        cache_examples=False  # Disable caching for examples to prevent startup validation errors
+        cache_examples=False,  # Disable caching for examples to prevent startup validation errors
+        concurrency_limit=None,
     )
 
 if __name__ == "__main__":
     logger.setLevel(logging.INFO)
     logging.getLogger().setLevel(logging.INFO)
-    demo.launch()
+    demo.launch(ssr_mode=False)

uv.lock

@@ -1310,7 +1310,7 @@ wheels = [
 
 [[package]]
 name = "opensymbiose"
-version = "0.0.2"
+version = "0.0.3"
 source = { editable = "." }
 dependencies = [
     { name = "biopython" },