solana-agent 19.1.0__py3-none-any.whl → 20.1.4__py3-none-any.whl

solana_agent/client/solana_agent.py

@@ -11,6 +11,7 @@ from typing import AsyncGenerator, Dict, Any, Literal, Optional, Union
 from solana_agent.factories.agent_factory import SolanaAgentFactory
 from solana_agent.interfaces.client.client import SolanaAgent as SolanaAgentInterface
 from solana_agent.interfaces.plugins.plugins import Tool
+from solana_agent.interfaces.services.routing import RoutingService as RoutingInterface
 
 
 class SolanaAgent(SolanaAgentInterface):
@@ -54,6 +55,7 @@ class SolanaAgent(SolanaAgentInterface):
         audio_input_format: Literal[
             "flac", "mp3", "mp4", "mpeg", "mpga", "m4a", "ogg", "wav", "webm"
         ] = "mp4",
+        router: Optional[RoutingInterface] = None,
     ) -> AsyncGenerator[Union[str, bytes], None]:  # pragma: no cover
         """Process a user message and return the response stream.
 
@@ -63,9 +65,10 @@ class SolanaAgent(SolanaAgentInterface):
             prompt: Optional prompt for the agent
             output_format: Response format ("text" or "audio")
             audio_voice: Voice to use for audio output
-            audio_instructions: Optional instructions for audio synthesis
+            audio_instructions: Not used currently
             audio_output_format: Audio output format
             audio_input_format: Audio input format
+            router: Optional routing service for processing
 
         Returns:
             Async generator yielding response chunks (text strings or audio bytes)
@@ -79,6 +82,7 @@ class SolanaAgent(SolanaAgentInterface):
             audio_output_format=audio_output_format,
             audio_input_format=audio_input_format,
             prompt=prompt,
+            router=router,
         ):
             yield chunk
 
@@ -97,7 +101,7 @@ class SolanaAgent(SolanaAgentInterface):
         page_num: int = 1,
         page_size: int = 20,
         sort_order: str = "desc"  # "asc" for oldest-first, "desc" for newest-first
-    ) -> Dict[str, Any]:
+    ) -> Dict[str, Any]:  # pragma: no cover
         """
         Get paginated message history for a user.
 
@@ -124,22 +128,11 @@ class SolanaAgent(SolanaAgentInterface):
         Returns:
             True if successful, False
         """
-
-        try:
-            print(f"Attempting to register tool: {tool.name}")
-            success = self.query_service.agent_service.tool_registry.register_tool(
-                tool)
-            if success:
-                print(f"Tool {tool.name} registered successfully")
-                # Get all agents and assign the tool to them
-                agents = self.query_service.agent_service.get_all_ai_agents()
-                for agent_name in agents:
-                    print(f"Assigning {tool.name} to agent {agent_name}")
-                    self.query_service.agent_service.assign_tool_for_agent(
-                        agent_name, tool.name)
-            return success
-        except Exception as e:
-            print(f"Error in register_tool: {str(e)}")
-            import traceback
-            print(traceback.format_exc())
-            return False
+        success = self.query_service.agent_service.tool_registry.register_tool(
+            tool)
+        if success:
+            agents = self.query_service.agent_service.get_all_ai_agents()
+            for agent_name in agents:
+                self.query_service.agent_service.assign_tool_for_agent(
+                    agent_name, tool.name)
+        return success

solana_agent/factories/agent_factory.py

@@ -109,8 +109,12 @@ class SolanaAgentFactory:
             config=config,
             tool_registry=agent_service.tool_registry
         )
-        loaded_plugins = agent_service.plugin_manager.load_plugins()
-        print(f"Loaded {loaded_plugins} plugins")
+        try:
+            loaded_plugins = agent_service.plugin_manager.load_plugins()
+            print(f"Loaded {loaded_plugins} plugins")
+        except Exception as e:
+            print(f"Error loading plugins: {e}")
+            loaded_plugins = 0
 
         # Register predefined agents
         for agent_config in config.get("agents", []):
@@ -125,25 +129,18 @@ class SolanaAgentFactory:
                 for tool_name in agent_config["tools"]:
                     print(
                         f"Available tools before registering {tool_name}: {agent_service.tool_registry.list_all_tools()}")
-                    try:
-                        agent_service.assign_tool_for_agent(
-                            agent_config["name"], tool_name
-                        )
-                        print(
-                            f"Successfully registered {tool_name} for agent {agent_config['name']}")
-                    except ValueError as e:
-                        print(
-                            f"Error registering tool {tool_name} for agent {agent_config['name']}: {e}")
+                    agent_service.assign_tool_for_agent(
+                        agent_config["name"], tool_name
+                    )
+                    print(
+                        f"Successfully registered {tool_name} for agent {agent_config['name']}")
 
         # Global tool registrations
         if "agent_tools" in config:
             for agent_name, tools in config["agent_tools"].items():
                 for tool_name in tools:
-                    try:
-                        agent_service.assign_tool_for_agent(
-                            agent_name, tool_name)
-                    except ValueError as e:
-                        print(f"Error registering tool: {e}")
+                    agent_service.assign_tool_for_agent(
+                        agent_name, tool_name)
 
         # Create and return the query service
         query_service = QueryService(

solana_agent/interfaces/services/routing.py

@@ -6,11 +6,10 @@ class RoutingService(ABC):
     """Interface for query routing services."""
 
     @abstractmethod
-    async def route_query(self, query: str) -> Tuple[str, Any]:
+    async def route_query(self, query: str) -> str:
         """Route a query to the appropriate agent.
 
         Args:
-            user_id: User ID
             query: User query
 
         Returns:

solana_agent/plugins/manager.py

@@ -35,19 +35,21 @@ class PluginManager(PluginManagerInterface):
             True if registration succeeded, False otherwise
         """
         try:
-            # Store plugin by name
-            self._plugins[plugin.name] = plugin
-
-            # Initialize the plugin with the tool registry
+            # Initialize the plugin with the tool registry first
             plugin.initialize(self.tool_registry)
 
-            # *** ADD THIS LINE: Configure the plugin with our config ***
-            print(f"Configuring plugin {plugin.name} with config")
+            # Then configure the plugin
             plugin.configure(self.config)
 
+            # Only store plugin if both initialize and configure succeed
+            self._plugins[plugin.name] = plugin
+            print(f"Successfully registered plugin {plugin.name}")
             return True
+
         except Exception as e:
             print(f"Error registering plugin {plugin.name}: {e}")
+            # Remove plugin from registry if it was added
+            self._plugins.pop(plugin.name, None)
             return False
 
     def load_plugins(self) -> List[str]:
@@ -59,30 +61,27 @@ class PluginManager(PluginManagerInterface):
         loaded_plugins = []
 
         # Discover plugins through entry points
-        try:
-            for entry_point in importlib.metadata.entry_points(group='solana_agent.plugins'):
-                # Skip if this entry point has already been loaded
-                entry_point_id = f"{entry_point.name}:{entry_point.value}"
-                if entry_point_id in PluginManager._loaded_entry_points:
-                    print(
-                        f"Skipping already loaded plugin: {entry_point.name}")
-                    continue
-
-                try:
-                    print(f"Found plugin entry point: {entry_point.name}")
-                    PluginManager._loaded_entry_points.add(entry_point_id)
-                    plugin_factory = entry_point.load()
-                    plugin = plugin_factory()
-
-                    # Register the plugin
-                    if self.register_plugin(plugin):
-                        # Use entry_point.name instead of plugin.name
-                        loaded_plugins.append(entry_point.name)
-
-                except Exception as e:
-                    print(f"Error loading plugin {entry_point.name}: {e}")
-        except Exception as e:
-            print(f"Error discovering plugins: {e}")
+        for entry_point in importlib.metadata.entry_points(group='solana_agent.plugins'):
+            # Skip if this entry point has already been loaded
+            entry_point_id = f"{entry_point.name}:{entry_point.value}"
+            if entry_point_id in PluginManager._loaded_entry_points:
+                print(
+                    f"Skipping already loaded plugin: {entry_point.name}")
+                continue
+
+            try:
+                print(f"Found plugin entry point: {entry_point.name}")
+                PluginManager._loaded_entry_points.add(entry_point_id)
+                plugin_factory = entry_point.load()
+                plugin = plugin_factory()
+
+                # Register the plugin
+                if self.register_plugin(plugin):
+                    # Use entry_point.name instead of plugin.name
+                    loaded_plugins.append(entry_point.name)
+
+            except Exception as e:
+                print(f"Error loading plugin {entry_point.name}: {e}")
 
         return loaded_plugins
 

solana_agent/plugins/registry.py

@@ -76,6 +76,23 @@ class ToolRegistry(ToolRegistryInterface):
         return list(self._tools.keys())
 
     def configure_all_tools(self, config: Dict[str, Any]) -> None:
-        """Configure all registered tools with the same config."""
-        for tool in self._tools.values():
-            tool.configure(config)
+        """Configure all registered tools with new configuration.
+
+        Args:
+            config: Configuration dictionary to apply
+        """
+        self._config.update(config)
+        configure_errors = []
+
+        for name, tool in self._tools.items():
+            try:
+                print(f"Configuring tool: {name}")
+                tool.configure(self._config)
+            except Exception as e:
+                print(f"Error configuring tool {name}: {e}")
+                configure_errors.append((name, str(e)))
+
+        if configure_errors:
+            print("The following tools failed to configure:")
+            for name, error in configure_errors:
+                print(f"- {name}: {error}")

solana_agent/plugins/tools/auto_tool.py

@@ -34,6 +34,8 @@ class AutoTool(Tool):
 
     def configure(self, config: Dict[str, Any]) -> None:
         """Configure the tool with settings from config."""
+        if config is None:
+            raise TypeError("Config cannot be None")
         self._config = config
 
     def get_schema(self) -> Dict[str, Any]:

solana_agent/repositories/memory.py

@@ -25,10 +25,13 @@ class MemoryRepository(MemoryProvider):
             self.mongo = mongo_adapter
             self.collection = "conversations"
 
-            # Ensure MongoDB collection and indexes
-            self.mongo.create_collection(self.collection)
-            self.mongo.create_index(self.collection, [("user_id", 1)])
-            self.mongo.create_index(self.collection, [("timestamp", 1)])
+            try:
+                # Ensure MongoDB collection and indexes
+                self.mongo.create_collection(self.collection)
+                self.mongo.create_index(self.collection, [("user_id", 1)])
+                self.mongo.create_index(self.collection, [("timestamp", 1)])
+            except Exception as e:
+                print(f"Error initializing MongoDB: {e}")
 
         # Initialize Zep
         if zep_api_key and not zep_base_url:
@@ -40,53 +43,78 @@ class MemoryRepository(MemoryProvider):
 
     async def store(self, user_id: str, messages: List[Dict[str, Any]]) -> None:
         """Store messages in both Zep and MongoDB."""
-        # Store in MongoDB as single document
-        if self.mongo:
+        if not user_id:
+            raise ValueError("User ID cannot be None or empty")
+        if not messages or not isinstance(messages, list):
+            raise ValueError("Messages must be a non-empty list")
+        if not all(isinstance(msg, dict) and "role" in msg and "content" in msg for msg in messages):
+            raise ValueError(
+                "All messages must be dictionaries with 'role' and 'content' keys")
+        for msg in messages:
+            if msg["role"] not in ["user", "assistant"]:
+                raise ValueError(
+                    f"Invalid role '{msg['role']}' in message. Only 'user' and 'assistant' roles are accepted.")
+
+        # Store in MongoDB
+        if self.mongo and len(messages) >= 2:
             try:
-                # Extract user and assistant messages
-                user_message = next(msg["content"]
-                                    for msg in messages if msg["role"] == "user")
-                assistant_message = next(
-                    msg["content"] for msg in messages if msg["role"] == "assistant")
-
-                doc = {
-                    "user_id": user_id,
-                    "user_message": user_message,
-                    "assistant_message": assistant_message,
-                    "timestamp": datetime.now(timezone.utc)
-                }
-                self.mongo.insert_one(self.collection, doc)
+                # Get last user and assistant messages
+                user_msg = None
+                assistant_msg = None
+                for msg in reversed(messages):
+                    if msg.get("role") == "user" and not user_msg:
+                        user_msg = msg.get("content")
+                    elif msg.get("role") == "assistant" and not assistant_msg:
+                        assistant_msg = msg.get("content")
+                    if user_msg and assistant_msg:
+                        break
+
+                if user_msg and assistant_msg:
+                    # Store truncated messages
+                    doc = {
+                        "user_id": user_id,
+                        "user_message": self._truncate(user_msg),
+                        "assistant_message": self._truncate(assistant_msg),
+                        "timestamp": datetime.now(timezone.utc)
+                    }
+                    self.mongo.insert_one(self.collection, doc)
             except Exception as e:
                 print(f"MongoDB storage error: {e}")
 
-        # Store in Zep with role-based format
+        # Store in Zep
         if not self.zep:
             return
 
         try:
-            try:
-                await self.zep.user.add(user_id=user_id)
-            except Exception:
-                pass
-            try:
-                await self.zep.memory.add_session(
-                    session_id=user_id,
-                    user_id=user_id,
-                )
-            except Exception:
-                pass
+            await self.zep.user.add(user_id=user_id)
+        except Exception as e:
+            print(f"Zep user addition error: {e}")
+
+        try:
+            await self.zep.memory.add_session(session_id=user_id, user_id=user_id)
+        except Exception as e:
+            print(f"Zep session creation error: {e}")
 
-            zep_messages = [
-                Message(
+        # Convert messages to Zep format
+        zep_messages = []
+        for msg in messages:
+            if "role" in msg and "content" in msg:
+                zep_msg = Message(
                     role=msg["role"],
+                    content=msg["content"],
                     role_type=msg["role"],
-                    content=self._truncate(msg["content"])
                 )
-                for msg in messages
-            ]
-            await self.zep.memory.add(session_id=user_id, messages=zep_messages)
-        except Exception as e:
-            print(f"Zep storage error: {e}")
+                zep_messages.append(zep_msg)
+
+        # Add messages to Zep memory
+        if zep_messages:
+            try:
+                await self.zep.memory.add(
+                    session_id=user_id,
+                    messages=zep_messages
+                )
+            except Exception as e:
+                print(f"Zep memory addition error: {e}")
 
     async def retrieve(self, user_id: str) -> str:
         """Retrieve memory context from Zep only."""
@@ -95,7 +123,8 @@ class MemoryRepository(MemoryProvider):
 
         try:
             memory = await self.zep.memory.get(session_id=user_id)
-
+            if memory is None or not hasattr(memory, 'context') or memory.context is None:
+                return ""
             return memory.context
 
         except Exception as e:
@@ -118,9 +147,13 @@ class MemoryRepository(MemoryProvider):
 
         try:
             await self.zep.memory.delete(session_id=user_id)
+        except Exception as e:
+            print(f"Zep memory deletion error: {e}")
+
+        try:
             await self.zep.user.delete(user_id=user_id)
         except Exception as e:
-            print(f"Zep deletion error: {e}")
+            print(f"Zep user deletion error: {e}")
 
     def find(
         self,
@@ -129,26 +162,38 @@ class MemoryRepository(MemoryProvider):
         sort: Optional[List[Tuple]] = None,
         limit: int = 0,
         skip: int = 0
-    ) -> List[Dict]:
-        """Find documents matching query."""
+    ) -> List[Dict]:  # pragma: no cover
+        """Find documents in MongoDB."""
         if not self.mongo:
             return []
-        return self.mongo.find(collection, query, sort=sort, limit=limit, skip=skip)
+
+        try:
+            return self.mongo.find(collection, query, sort=sort, limit=limit, skip=skip)
+        except Exception as e:
+            print(f"MongoDB find error: {e}")
+            return []
 
     def count_documents(self, collection: str, query: Dict) -> int:
-        """Count documents matching query."""
+        """Count documents in MongoDB."""
         if not self.mongo:
             return 0
         return self.mongo.count_documents(collection, query)
 
     def _truncate(self, text: str, limit: int = 2500) -> str:
         """Truncate text to be within limits."""
+        if text is None:
+            raise AttributeError("Cannot truncate None text")
+
+        if not text:
+            return ""
+
         if len(text) <= limit:
             return text
 
-        truncated = text[:limit]
-        last_period = truncated.rfind(".")
-        if last_period > limit * 0.8:
-            return truncated[:last_period + 1]
+        # Try to truncate at last period before limit
+        last_period = text.rfind('.', 0, limit)
+        if last_period > 0:
+            return text[:last_period + 1]
 
-        return truncated + "..."
+        # If no period found, truncate at limit and add ellipsis
+        return text[:limit] + "..."

solana_agent/services/agent.py

@@ -12,7 +12,7 @@ from typing import AsyncGenerator, Dict, List, Literal, Optional, Any, Union
 
 from solana_agent.interfaces.services.agent import AgentService as AgentServiceInterface
 from solana_agent.interfaces.providers.llm import LLMProvider
-from solana_agent.interfaces.plugins.plugins import ToolRegistry as ToolRegistryInterface
+from solana_agent.plugins.manager import PluginManager
 from solana_agent.plugins.registry import ToolRegistry
 from solana_agent.domains.agent import AIAgent, BusinessMission
 
@@ -40,8 +40,10 @@ class AgentService(AgentServiceInterface):
         self.tool_registry = ToolRegistry(config=self.config)
         self.agents: List[AIAgent] = []
 
-        # Will be set by factory if plugin system is enabled
-        self.plugin_manager = None
+        self.plugin_manager = PluginManager(
+            config=self.config,
+            tool_registry=self.tool_registry,
+        )
 
     def register_ai_agent(
         self, name: str, instructions: str, specialization: str,

solana_agent/services/query.py

@@ -8,6 +8,7 @@ clean separation of concerns.
 from typing import Any, AsyncGenerator, Dict, Literal, Optional, Union
 
 from solana_agent.interfaces.services.query import QueryService as QueryServiceInterface
+from solana_agent.interfaces.services.routing import RoutingService as RoutingServiceInterface
 from solana_agent.services.agent import AgentService
 from solana_agent.services.routing import RoutingService
 from solana_agent.interfaces.providers.memory import MemoryProvider
@@ -47,6 +48,7 @@ class QueryService(QueryServiceInterface):
             "flac", "mp3", "mp4", "mpeg", "mpga", "m4a", "ogg", "wav", "webm"
         ] = "mp4",
         prompt: Optional[str] = None,
+        router: Optional[RoutingServiceInterface] = None,
     ) -> AsyncGenerator[Union[str, bytes], None]:  # pragma: no cover
         """Process the user request with appropriate agent.
 
@@ -59,6 +61,7 @@ class QueryService(QueryServiceInterface):
             audio_output_format: Audio output format
             audio_input_format: Audio input format
             prompt: Optional prompt for the agent
+            router: Optional routing service for processing
 
         Yields:
             Response chunks (text strings or audio bytes)
@@ -96,7 +99,11 @@ class QueryService(QueryServiceInterface):
                 memory_context = await self.memory_provider.retrieve(user_id)
 
             # Route query to appropriate agent
-            agent_name = await self.routing_service.route_query(user_text)
+            if router:
+                agent_name = await router.route_query(user_text)
+            else:
+                agent_name = await self.routing_service.route_query(user_text)
+
             print(f"Routed to agent: {agent_name}")
 
             # Generate response

solana_agent/services/routing.py

@@ -95,7 +95,7 @@ class RoutingService(RoutingServiceInterface):
                 "confidence": 0.0
             }
 
-    async def route_query(self, query: str) -> str:
+    async def route_query(self, query: str) -> str:  # pragma: no cover
         """Route a query to the appropriate agent.
 
         Args:

{solana_agent-19.1.0.dist-info → solana_agent-20.1.4.dist-info}/METADATA

@@ -1,23 +1,25 @@
 Metadata-Version: 2.3
 Name: solana-agent
-Version: 19.1.0
+Version: 20.1.4
 Summary: Agentic IQ
 License: MIT
 Keywords: ai,openai,ai agents,agi
 Author: Bevan Hunt
 Author-email: bevan@bevanhunt.com
 Requires-Python: >=3.12,<4.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Requires-Dist: openai (>=1.69.0,<2.0.0)
-Requires-Dist: pydantic (>=2.11.0,<3.0.0)
+Requires-Dist: openai (>=1.68.2,<2.0.0)
+Requires-Dist: pydantic (>=2.11.1,<3.0.0)
 Requires-Dist: pymongo (>=4.11.3,<5.0.0)
 Requires-Dist: zep-cloud (>=2.8.0,<3.0.0)
 Requires-Dist: zep-python (>=2.0.2,<3.0.0)
+Project-URL: Documentation, https://docs.solana-agent.com
 Project-URL: Repository, https://github.com/truemagic-coder/solana-agent
 Description-Content-Type: text/markdown
 
@@ -46,6 +48,7 @@ Build your AI business in three lines of code!
 * Extensible Tooling
 * Simple Business Definition
 * Tested & Secure
+* Support for MCP Servers
 * Built in Python
 * Deployed by [CometHeart](https://cometheart.com) & [WalletBubbles](https://walletbubbles.com)
 
@@ -54,11 +57,12 @@ Build your AI business in three lines of code!
 * Seamless text and audio streaming with real-time multi-modal processing
 * Persistent memory that preserves context across all agent interactions
 * Streamlined message history for all agent interactions
-* Intelligent query routing to agents with optimal domain expertise
+* Intelligent query routing to agents with optimal domain expertise or your own custom routing
 * Unified value system ensuring brand-aligned agent responses
 * Powerful tool integration using standard Python packages and/or inline classes
 * Assigned tools are utilized by agents automatically and effectively
 * Simple business definition using JSON
+* Ability to access any MCP server via a URL
 
 ## Stack
 
@@ -73,13 +77,13 @@ You can install Solana Agent using pip:
 
 `pip install solana-agent`
 
-## Basic Usage
+## Usage
 
-```python
-from solana_agent import SolanaAgent
+### Business Alignment Config - Optional
 
+```python
 config = {
-    "business": { # optional
+    "business": {
         "mission": "To provide users with a one-stop shop for their queries.",
         "values": {
             "Friendliness": "Users must be treated fairly, openly, and with friendliness.",
@@ -90,14 +94,37 @@ config = {
         ],
         "voice": "The voice of the brand is that of a research business."
     },
-    "mongo": { # optional
+}
+```
+
+### Conversational History Config - Optional
+
+```python
+config = {
+    "mongo": {
         "connection_string": "mongodb://localhost:27017",
         "database": "solana_agent"
     },
-    "zep": { # optional
+}
+```
+
+### Conversational Memory Config - Optional
+
+```python
+config = {
+    "zep": {
         "api_key": "your-zep-api-key",
         "base_url": "your-zep-base-url", # not applicable if using Zep Cloud
     },
+}
+```
+
+### Text/Text Streaming
+
+```python
+from solana_agent import SolanaAgent
+
+config = {
     "openai": {
         "api_key": "your-openai-api-key",
     },
@@ -121,40 +148,110 @@ async for response in solana_agent.process("user123", "What are the latest AI de
     print(response, end="")
 ```
 
-## Plugin Usage
+### Audio/Audio Streaming
 
-Plugins like Solana Agent Kit (sakit) integrate automatically with Solana Agent.
+```python
+from solana_agent import SolanaAgent
 
-`pip install sakit`
+config = {
+    "openai": {
+        "api_key": "your-openai-api-key",
+    },
+    "agents": [
+        {
+            "name": "research_specialist",
+            "instructions": "You are an expert researcher who synthesizes complex information clearly.",
+            "specialization": "Research and knowledge synthesis",
+        },
+        {
+            "name": "customer_support",
+            "instructions": "You provide friendly, helpful customer support responses.",
+            "specialization": "Customer inquiries",
+        }
+    ],
+}
+
+solana_agent = SolanaAgent(config=config)
+
+audio_content = audio_file.read()
+
+async for response in solana_agent.process("user123", audio_content, output_format="audio", audio_voice="nova", audio_input_format="webm", audio_output_format="aac"):
+    print(response, end="")
+```
+
+### Text/Audio Streaming
 
 ```python
 from solana_agent import SolanaAgent
 
 config = {
-    "business": { # optional
-        "mission": "To provide users with a one-stop shop for their queries.",
-        "values": {
-            "Friendliness": "Users must be treated fairly, openly, and with friendliness.",
-            "Ethical": "Agents must use a strong ethical framework in their interactions with users.",
-        },
-        "goals": [
-            "Empower users with great answers to their queries.",
-        ],
-        "voice": "The voice of the brand is that of a research business."
-    },
-    "openai": { # optional
+    "openai": {
         "api_key": "your-openai-api-key",
     },
-    "ollama": { # optional
-        "url": "your-ollama-url",
-    },
-    "mongo": { # optional
-        "connection_string": "mongodb://localhost:27017",
-        "database": "solana_agent"
+    "agents": [
+        {
+            "name": "research_specialist",
+            "instructions": "You are an expert researcher who synthesizes complex information clearly.",
+            "specialization": "Research and knowledge synthesis",
+        },
+        {
+            "name": "customer_support",
+            "instructions": "You provide friendly, helpful customer support responses.",
+            "specialization": "Customer inquiries",
+        }
+    ],
+}
+
+solana_agent = SolanaAgent(config=config)
+
+async for response in solana_agent.process("user123", "What is the latest news on Elon Musk?", output_format="audio", audio_voice="nova", audio_output_format="aac"):
+    print(response, end="")
+```
+
+### Audio/Text Streaming
+
+```python
+from solana_agent import SolanaAgent
+
+config = {
+    "openai": {
+        "api_key": "your-openai-api-key",
     },
-    "zep": { # optional
-        "api_key": "your-zep-api-key",
-        "base_url": "your-zep-base-url", # not applicable if using Zep Cloud
+    "agents": [
+        {
+            "name": "research_specialist",
+            "instructions": "You are an expert researcher who synthesizes complex information clearly.",
+            "specialization": "Research and knowledge synthesis",
+        },
+        {
+            "name": "customer_support",
+            "instructions": "You provide friendly, helpful customer support responses.",
+            "specialization": "Customer inquiries",
+        }
+    ],
+}
+
+solana_agent = SolanaAgent(config=config)
+
+audio_content = audio_file.read()
+
+async for response in solana_agent.process("user123", audio_content, audio_input_format="aac"):
+    print(response, end="")
+```
+
+### Plugins
+
+Plugins like Solana Agent Kit (sakit) integrate automatically with Solana Agent.
+
+`pip install sakit`
+
+#### Internet Search
+```python
+from solana_agent import SolanaAgent
+
+config = {
+    "openai": {
+        "api_key": "your-openai-api-key",
     },
     "tools": {
         "search_internet": {
@@ -184,9 +281,47 @@ async for response in solana_agent.process("user123", "What are the latest AI de
     print(response, end="")
 ```
 
+#### MCP
+```python
+from solana_agent import SolanaAgent
+
+config = {
+    "openai": {
+        "api_key": "your-openai-api-key",
+    },
+    "tools": {
+        "mcp": {
+            "server_urls": [
+                "http://mcp-server1.com/mcp",
+                "http://mcp-server2.com/mcp",
+                "http://mcp-server3.com/mcp"
+            ]
+        }
+    },
+    "agents": [
+        {
+            "name": "research_specialist",
+            "instructions": "You are an expert researcher who synthesizes complex information clearly.",
+            "specialization": "Research and knowledge synthesis",
+            "tools": ["mcp"],
+        },
+        {
+            "name": "customer_support",
+            "instructions": "You provide friendly, helpful customer support responses.",
+            "specialization": "Customer inquiries",
+        }
+    ],
+}
+
+solana_agent = SolanaAgent(config=config)
+
+async for response in solana_agent.process("user123", "What are the latest AI developments?"):
+    print(response, end="")
+```
+
 To create a plugin like Solana Agent Kit - read the [code](https://github.com/truemagic-coder/solana-agent-kit)
 
-## Custom Inline Tool Usage
+### Custom Inline Tools
 
 ```python
 from solana_agent import SolanaAgent
@@ -239,31 +374,9 @@ class TestTool(Tool):
             }
 
 config = {
-    "business": { # optional
-        "mission": "To provide users with a one-stop shop for their queries.",
-        "values": {
-            "Friendliness": "Users must be treated fairly, openly, and with friendliness.",
-            "Ethical": "Agents must use a strong ethical framework in their interactions with users.",
-        },
-        "goals": [
-            "Empower users with great answers to their queries.",
-        ],
-        "voice": "The voice of the brand is that of a research business."
-    },
-    "openai": { # optional
+    "openai": {
         "api_key": "your-openai-api-key",
     },
-    "ollama": { # optional
-        "url": "your-ollama-url",
-    },
-    "mongo": { # optional
-        "connection_string": "mongodb://localhost:27017",
-        "database": "solana_agent"
-    },
-    "zep": { # optional
-        "api_key": "your-zep-api-key",
-        "base_url": "your-zep-base-url", # not applicable if using Zep Cloud
-    },
     "agents": [
         {
             "name": "research_specialist",
@@ -288,12 +401,81 @@ async for response in solana_agent.process("user123", "What are the latest AI de
     print(response, end="")
 ```
 
+### Custom Prompt Injection at Runtime
+
+```python
+from solana_agent import SolanaAgent
+
+config = {
+    "openai": {
+        "api_key": "your-openai-api-key",
+    },
+    "agents": [
+        {
+            "name": "research_specialist",
+            "instructions": "You are an expert researcher who synthesizes complex information clearly.",
+            "specialization": "Research and knowledge synthesis",
+        },
+        {
+            "name": "customer_support",
+            "instructions": "You provide friendly, helpful customer support responses.",
+            "specialization": "Customer inquiries",
+        }
+    ],
+}
+
+solana_agent = SolanaAgent(config=config)
+
+async for response in solana_agent.process("user123", "What are the latest AI developments?", "Always end your sentences with eh?"):
+    print(response, end="")
+```
+
+### Custom Routing
+
+```python
+from solana_agent import SolanaAgent
+from solana_agent.interfaces.services.routing import RoutingService as RoutingServiceInterface
+
+config = {
+    "openai": {
+        "api_key": "your-openai-api-key",
+    },
+    "agents": [
+        {
+            "name": "research_specialist",
+            "instructions": "You are an expert researcher who synthesizes complex information clearly.",
+            "specialization": "Research and knowledge synthesis",
+        },
+        {
+            "name": "customer_support",
+            "instructions": "You provide friendly, helpful customer support responses.",
+            "specialization": "Customer inquiries",
+        }
+    ],
+}
+
+class Router(RoutingServiceInterface)
+    def __init__(self):
+        # your router initialization - delete the following pass
+        pass
+
+    async def route_query(self, query: str) -> str:
+        # a simple example to route always to customer_support agent
+        return "customer_support"
+
+router = Router()
+
+solana_agent = SolanaAgent(config=config)
+
+async for response in solana_agent.process("user123", "What are the latest AI developments?", router=router):
+    print(response, end="")
+```
+
 ## Notes
 * Solana Agent agents can only call one tool per response.
 * Solana Agent agents choose the best tool for the job.
 * Solana Agent tools do not use OpenAI function calling.
 * Solana Agent tools are async functions.
-* Solana Agent will use OpenAI for audio and Ollama and for text if both config vars are set
 
 ## Local Setup
 

{solana_agent-19.1.0.dist-info → solana_agent-20.1.4.dist-info}/RECORD

@@ -3,12 +3,12 @@ solana_agent/adapters/__init__.py,sha256=tiEEuuy0NF3ngc_tGEcRTt71zVI58v3dYY9RvMr
 solana_agent/adapters/llm_adapter.py,sha256=3_7whVsPSJdlzBVUBlV7RBRCCo2dMXNmlACIrCoQxQ4,5426
 solana_agent/adapters/mongodb_adapter.py,sha256=qqEFbY_v1XGyFXBmwd5HSXSSHnA9wWo-Hm1vGEyIG0k,2718
 solana_agent/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-solana_agent/client/solana_agent.py,sha256=sN8imsCMm2SqsF4c4moumno1V6OPPAABv1IJw9P7QbU,5476
+solana_agent/client/solana_agent.py,sha256=4xXPNNcULMEIx-V-_zu2IH0tlPjQU2ZzkIqZFuxAJHY,5206
 solana_agent/domains/__init__.py,sha256=HiC94wVPRy-QDJSSRywCRrhrFfTBeHjfi5z-QfZv46U,168
 solana_agent/domains/agent.py,sha256=WTo-pEc66V6D_35cpDE-kTsw1SJM-dtylPZ7em5em7Q,2659
 solana_agent/domains/routing.py,sha256=UDlgTjUoC9xIBVYu_dnf9-KG_bBgdEXAv_UtDOrYo0w,650
 solana_agent/factories/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-solana_agent/factories/agent_factory.py,sha256=v_Q0bKPoZOQ8e6pS4gcYeCpE-jSbktOhVF5oaAXn_-I,5779
+solana_agent/factories/agent_factory.py,sha256=c5TgZpDZ6m_q8F-Bv36Rl4dXq5yWNvAN2q9Nq_PtqqM,5547
 solana_agent/interfaces/__init__.py,sha256=IQs1WIM1FeKP1-kY2FEfyhol_dB-I-VAe2rD6jrVF6k,355
 solana_agent/interfaces/client/client.py,sha256=c9n5uF7UzwqCTU-jFz-33eq9TRyora_A5UbO4-EYlJU,1503
 solana_agent/interfaces/plugins/plugins.py,sha256=T8HPBsekmzVwfU_Rizp-vtzAeYkMlKMYD7U9d0Wjq9c,3338
@@ -17,19 +17,19 @@ solana_agent/interfaces/providers/llm.py,sha256=f58kDrvESBfIr2XoZJ-VVa8vL56qyuhk
 solana_agent/interfaces/providers/memory.py,sha256=oNOH8WZXVW8assDigIWZAWiwkxbpDiKupxA2RB6tQvQ,1010
 solana_agent/interfaces/services/agent.py,sha256=34luGrUF5FNXLhF6JXwbfOSuo_SbMOmLMywG310sMDw,2082
 solana_agent/interfaces/services/query.py,sha256=m8Uc0uXT3apSOhX3N1QjLMPk1KdJhj7HDrJjWUpDPBc,1309
-solana_agent/interfaces/services/routing.py,sha256=gohkt5f9uYDLpu4iDVDk9yj8js9P56R6QHSIDNylgwA,438
+solana_agent/interfaces/services/routing.py,sha256=UzJC-z-Q9puTWPFGEo2_CAhIxuxP5IRnze7S66NSrsI,397
 solana_agent/plugins/__init__.py,sha256=coZdgJKq1ExOaj6qB810i3rEhbjdVlrkN76ozt_Ojgo,193
-solana_agent/plugins/manager.py,sha256=sdHq6Cqn4juvgS6_3Iu_yjLVAcTRoIkPCqw8fWPkxgw,5096
-solana_agent/plugins/registry.py,sha256=ZUeczZ9bkdm9G6NBMDpY7sglOW2IrJLiLhboMNAHors,3072
+solana_agent/plugins/manager.py,sha256=Il49hXeqvu0b02pURNNp7mY8kp9_sqpi_vJIWBW5Hc0,5044
+solana_agent/plugins/registry.py,sha256=5S0DlUQKogsg1zLiRUIGMHEmGYHtOovU-S-5W1Mwo1A,3639
 solana_agent/plugins/tools/__init__.py,sha256=c0z7ij42gs94_VJrcn4Y8gUlTxMhsFNY6ahIsNswdLk,231
-solana_agent/plugins/tools/auto_tool.py,sha256=eDq2P-_D2PM7Dafpn55b1QU5LkM6BLdJGiWB9Wz8d_M,1495
+solana_agent/plugins/tools/auto_tool.py,sha256=DgES_cZ6xKSf_HJpFINpvJxrjVlk5oeqa7pZRBsR9SM,1575
 solana_agent/repositories/__init__.py,sha256=fP83w83CGzXLnSdq-C5wbw9EhWTYtqE2lQTgp46-X_4,163
-solana_agent/repositories/memory.py,sha256=xvgFscvnIGicIB9r1RwavhXSXGt2KRrloIheG3OWs-I,5221
+solana_agent/repositories/memory.py,sha256=eecl1P0fr_xFSWFKIJg99q90oCS9--ihPrMLH3G2AzM,7136
 solana_agent/services/__init__.py,sha256=ab_NXJmwYUCmCrCzuTlZ47bJZINW0Y0F5jfQ9OovidU,163
-solana_agent/services/agent.py,sha256=o8RJg1pBREfTK5gCLS2A0Lprg36gvn0Hzh6_TS1Hx6Y,16448
-solana_agent/services/query.py,sha256=4MEGR_Q2THcCCjln-IcSAw7GGNqJ1q2cyEVRx69OQ7I,10746
-solana_agent/services/routing.py,sha256=IPvBicgTYXqQ8iIRaatCsBGQVsOBGdAkq2i6U8hZlOY,6479
-solana_agent-19.1.0.dist-info/LICENSE,sha256=BnSRc-NSFuyF2s496l_4EyrwAP6YimvxWcjPiJ0J7g4,1057
-solana_agent-19.1.0.dist-info/METADATA,sha256=DD7fvgmWqOjDOTYePcppCLZP-gs0kOu-S9mUyOFxV7w,10859
-solana_agent-19.1.0.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-solana_agent-19.1.0.dist-info/RECORD,,
+solana_agent/services/agent.py,sha256=MdSPIC81JNuP2hfzXNGWOnRfe7OxwYHgDVZAphVCCo8,16450
+solana_agent/services/query.py,sha256=QduAeiltFTwNDlAbC_emu544U4XGNioj-OauRGt9HSY,11070
+solana_agent/services/routing.py,sha256=PMCSG5m3uLMaHMj3dxNvNfcFZaeaDi7kMr7AEBCzwDE,6499
+solana_agent-20.1.4.dist-info/LICENSE,sha256=BnSRc-NSFuyF2s496l_4EyrwAP6YimvxWcjPiJ0J7g4,1057
+solana_agent-20.1.4.dist-info/METADATA,sha256=fnqm3cRwxnmHdvW2-2H1Xlg5n-h10Tzyh3rKE3G7VnI,15083
+solana_agent-20.1.4.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+solana_agent-20.1.4.dist-info/RECORD,,