agentr 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

agentr/server.py

@@ -1,105 +1,128 @@
-from abc import ABC, abstractmethod
-from typing import Literal
-from mcp.server.fastmcp import FastMCP
-from agentr.integration import AgentRIntegration, ApiKeyIntegration
-from agentr.store import EnvironmentStore, MemoryStore
-from pydantic import BaseModel
-from loguru import logger
-
-class StoreConfig(BaseModel):
-    type: Literal["memory", "environment"]
-
-class IntegrationConfig(BaseModel):
-    name: str
-    type: Literal["api_key", "agentr"]
-    credentials: dict | None = None
-    store: StoreConfig | None = None
-
-class AppConfig(BaseModel):
-    name: str
-    integration: IntegrationConfig | None = None
-
-class Server(FastMCP, ABC):
-    """
-    Server is responsible for managing the applications and the store
-    It also acts as a router for the applications, and exposed to the client
-
-    """
-    def __init__(self, name: str, description: str, **kwargs):
-        super().__init__(name, description, **kwargs)
-
-    @abstractmethod
-    def _load_apps(self):
-        pass
-
-
-class TestServer(Server):
-    """
-    Test server for development purposes
-    """
-    def __init__(self, name: str, description: str, apps_list: list[AppConfig] = [], **kwargs):
-        super().__init__(name, description=description, **kwargs)
-        self.apps_list = [AppConfig.model_validate(app) for app in apps_list]
-        self._load_apps()
-    
-    def _get_store(self, store_config: StoreConfig):
-        if store_config.type == "memory":
-            return MemoryStore()
-        elif store_config.type == "environment":
-            return EnvironmentStore()
-        return None
-
-    def _get_integration(self, integration_config: IntegrationConfig):
-        if integration_config.type == "api_key":
-            store = self._get_store(integration_config.store)
-            integration = ApiKeyIntegration(integration_config.name, store=store)
-            if integration_config.credentials:
-                integration.set_credentials(integration_config.credentials)
-            return integration
-        elif integration_config.type == "agentr":
-            integration = AgentRIntegration(integration_config.name, api_key=integration_config.credentials.get("api_key") if integration_config.credentials else None)
-            return integration
-        return None
-    
-    def _load_app(self, app_config: AppConfig):
-        name = app_config.name
-        if name == "zenquotes":
-            from agentr.applications.zenquotes.app import ZenQuoteApp
-            return ZenQuoteApp()
-        elif name == "tavily":
-            from agentr.applications.tavily.app import TavilyApp
-            integration = self._get_integration(app_config.integration)
-            return TavilyApp(integration=integration)
-        elif name == "github":
-            from agentr.applications.github.app import GithubApp
-            integration = self._get_integration(app_config.integration)
-            return GithubApp(integration=integration)
-        elif name == "google-calendar":
-            from agentr.applications.google_calendar.app import GoogleCalendarApp
-            integration = self._get_integration(app_config.integration)
-            return GoogleCalendarApp(integration=integration)
-        elif name == "gmail":
-            from agentr.applications.google_mail.app import GmailApp
-            integration = self._get_integration(app_config.integration)
-            return GmailApp(integration=integration)
-        elif name == "resend":
-            from agentr.applications.resend.app import ResendApp
-            integration = self._get_integration(app_config.integration)
-            return ResendApp(integration=integration)
-        elif name == "reddit":
-            from agentr.applications.reddit.app import RedditApp
-            integration = self._get_integration(app_config.integration)
-            return RedditApp(integration=integration)
-        else:
-            return None
-            
-    def _load_apps(self):
-        logger.info(f"Loading apps: {self.apps_list}")
-        for app_config in self.apps_list:
-            app = self._load_app(app_config)
-            if app:
-                tools = app.list_tools()
-                for tool in tools:
-                    self.add_tool(tool)
-
-                
+from abc import ABC, abstractmethod
+import httpx
+from mcp.server.fastmcp import FastMCP
+from agentr.applications import app_from_name
+from agentr.exceptions import NotAuthorizedError
+from agentr.integration import AgentRIntegration, ApiKeyIntegration
+from agentr.store import EnvironmentStore, MemoryStore
+from agentr.config import AppConfig, IntegrationConfig, StoreConfig
+from loguru import logger
+import os
+from typing import Any
+from mcp.types import TextContent
+from mcp.server.fastmcp.exceptions import ToolError
+
+class Server(FastMCP, ABC):
+    """
+    Server is responsible for managing the applications and the store
+    It also acts as a router for the applications, and exposed to the client
+
+    """
+    def __init__(self, name: str, description: str, **kwargs):
+        super().__init__(name, description, **kwargs)
+
+    @abstractmethod
+    def _load_apps(self):
+        pass
+
+    async def call_tool(self, name: str, arguments: dict[str, Any]):
+        """Call a tool by name with arguments."""
+        try:
+            result = await super().call_tool(name, arguments)
+            return result
+        except ToolError as e:
+            raised_error = e.__cause__
+            if isinstance(raised_error, NotAuthorizedError):
+                return [TextContent(type="text", text=raised_error.message)]
+            else:
+                raise e
+
+class LocalServer(Server):
+    """
+    Local server for development purposes
+    """
+    def __init__(self, name: str, description: str, apps_list: list[AppConfig] = [], **kwargs):
+        super().__init__(name, description=description, **kwargs)
+        self.apps_list = [AppConfig.model_validate(app) for app in apps_list]
+        self._load_apps()
+    
+    def _get_store(self, store_config: StoreConfig):
+        if store_config.type == "memory":
+            return MemoryStore()
+        elif store_config.type == "environment":
+            return EnvironmentStore()
+        return None
+
+    def _get_integration(self, integration_config: IntegrationConfig):
+        if not integration_config:
+            return None
+        if integration_config.type == "api_key":
+            store = self._get_store(integration_config.store)
+            integration = ApiKeyIntegration(integration_config.name, store=store)
+            if integration_config.credentials:
+                integration.set_credentials(integration_config.credentials)
+            return integration
+        elif integration_config.type == "agentr":
+            integration = AgentRIntegration(integration_config.name, api_key=integration_config.credentials.get("api_key") if integration_config.credentials else None)
+            return integration
+        return None
+    
+    def _load_app(self, app_config: AppConfig):
+        name = app_config.name
+        integration = self._get_integration(app_config.integration)
+        app = app_from_name(name)(integration=integration)
+        return app
+            
+    def _load_apps(self):
+        logger.info(f"Loading apps: {self.apps_list}")
+        for app_config in self.apps_list:
+            app = self._load_app(app_config)
+            if app:
+                tools = app.list_tools()
+                for tool in tools:
+                    self.add_tool(tool)
+
+                
+
+class AgentRServer(Server):
+    """
+    AgentR server. Connects to the AgentR API to get the apps and tools. Only supports agentr integrations.
+    """
+    def __init__(self, name: str, description: str, api_key: str | None = None, **kwargs):
+        super().__init__(name, description=description, **kwargs)
+        self.api_key = api_key or os.getenv("AGENTR_API_KEY")
+        self.base_url = os.getenv("AGENTR_BASE_URL", "https://api.agentr.dev")
+        if not self.api_key:
+            raise ValueError("API key required - get one at https://agentr.dev")
+        self._load_apps()
+    
+    def _load_app(self, app_config: AppConfig):
+        name = app_config.name
+        if app_config.integration:
+            integration_name = app_config.integration.name
+            integration = AgentRIntegration(integration_name, api_key=self.api_key)
+        else:
+            integration = None
+        app = app_from_name(name)(integration=integration)
+        return app
+        
+    def _list_apps_with_integrations(self):
+        # TODO: get this from the API
+        response = httpx.get(
+            f"{self.base_url}/api/apps/",
+            headers={
+                "X-API-KEY": self.api_key
+            }
+        )
+        apps = response.json()
+        logger.info(f"Apps: {apps}")
+        return [AppConfig.model_validate(app) for app in apps]
+            
+    def _load_apps(self):
+        apps = self._list_apps_with_integrations()
+        for app in apps:
+            app = self._load_app(app)
+            if app:
+                tools = app.list_tools()
+                for tool in tools:
+                    self.add_tool(tool)

agentr/store.py

@@ -1,71 +1,71 @@
-import os
-from abc import ABC, abstractmethod
-
-
-class Store(ABC):
-    @abstractmethod
-    def get(self, key: str):
-        pass
-
-    @abstractmethod
-    def set(self, key: str, value: str):
-        pass
-
-    @abstractmethod
-    def delete(self, key: str):
-        pass
-
-class MemoryStore:
-    """
-    Acts as credential store for the applications.
-    Responsible for storing and retrieving credentials. 
-    Ideally should be a key value store
-    """
-    def __init__(self):
-        self.data = {}
-
-    def get(self, key: str):
-        return self.data.get(key)
-
-    def set(self, key: str, value: str):
-        self.data[key] = value
-
-    def delete(self, key: str):
-        del self.data[key]
-
-
-class EnvironmentStore(Store):
-    """
-    Store that uses environment variables to store credentials.
-    """
-    def __init__(self):
-        pass
-
-    def get(self, key: str):
-        return {"api_key": os.getenv(key)}
-
-    def set(self, key: str, value: str):
-        os.environ[key] = value
-
-    def delete(self, key: str):
-        del os.environ[key]
-
-class RedisStore(Store):
-    """
-    Store that uses a redis database to store credentials.
-    """
-    def __init__(self, host: str, port: int, db: int):
-        import redis
-        self.host = host
-        self.port = port
-        self.db = db
-        self.redis = redis.Redis(host=self.host, port=self.port, db=self.db)
-
-    def get(self, key: str):
-        return self.redis.get(key)
-
-    def set(self, key: str, value: str):
-        self.redis.set(key, value)
-
-    def delete(self, key: str):
+import os
+from abc import ABC, abstractmethod
+
+
+class Store(ABC):
+    @abstractmethod
+    def get(self, key: str):
+        pass
+
+    @abstractmethod
+    def set(self, key: str, value: str):
+        pass
+
+    @abstractmethod
+    def delete(self, key: str):
+        pass
+
+class MemoryStore:
+    """
+    Acts as credential store for the applications.
+    Responsible for storing and retrieving credentials. 
+    Ideally should be a key value store
+    """
+    def __init__(self):
+        self.data = {}
+
+    def get(self, key: str):
+        return self.data.get(key)
+
+    def set(self, key: str, value: str):
+        self.data[key] = value
+
+    def delete(self, key: str):
+        del self.data[key]
+
+
+class EnvironmentStore(Store):
+    """
+    Store that uses environment variables to store credentials.
+    """
+    def __init__(self):
+        pass
+
+    def get(self, key: str):
+        return {"api_key": os.getenv(key)}
+
+    def set(self, key: str, value: str):
+        os.environ[key] = value
+
+    def delete(self, key: str):
+        del os.environ[key]
+
+class RedisStore(Store):
+    """
+    Store that uses a redis database to store credentials.
+    """
+    def __init__(self, host: str, port: int, db: int):
+        import redis
+        self.host = host
+        self.port = port
+        self.db = db
+        self.redis = redis.Redis(host=self.host, port=self.port, db=self.db)
+
+    def get(self, key: str):
+        return self.redis.get(key)
+
+    def set(self, key: str, value: str):
+        self.redis.set(key, value)
+
+    def delete(self, key: str):
         self.redis.delete(key)

agentr/test.py

@@ -1,38 +1,15 @@
-from agentr.server import TestServer
-from agentr.store import MemoryStore
-
-store = MemoryStore()
-apps_list = [
-    {
-        "name": "tavily",
-        "integration": {
-            "name": "tavily_api_key",
-            "type": "api_key",
-            "store": {
-                "type": "environment",
-            }
-        },        
-    },
-    {
-        "name": "zenquotes",
-        "integration": None
-    },
-    {
-        "name": "github",
-        "integration": {
-            "name": "github",
-            "type": "agentr",
-        }
-    }
-]
-mcp = TestServer(name="Test Server", description="Test Server", apps_list=apps_list)
-
-async def test():
-    tools = await mcp.list_tools()
-    print(tools)
-    result = await mcp.call_tool("star_repository", {"repo_full_name": "manojbajaj95/config"})
-    print(result)
-
-if __name__ == "__main__":
-    import asyncio
+from agentr.server import AgentRServer
+
+
+mcp = AgentRServer(name="Test Server", description="Test Server")
+
+async def test():
+    tools = await mcp.list_tools()
+    from pprint import pprint
+    pprint(tools)
+    result = await mcp.call_tool("get_today_events", {})
+    print(result)
+
+if __name__ == "__main__":
+    import asyncio
     asyncio.run(test())