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

agentr/integration.py

@@ -1,98 +1,85 @@
-from abc import ABC, abstractmethod
-import os
-import sys
-
-from loguru import logger
-from agentr.store import Store
-import httpx
-
-"""
-Integration defines how a Application needs to authorize.
-It is responsible for authenticating application with the service provider.
-Supported integrations:
-- AgentR Integration
-- API Key Integration
-"""
-
-class Integration(ABC):
-    def __init__(self, name: str, store: Store = None):
-        self.name = name
-        self.store = store
-
-    @abstractmethod
-    def get_credentials(self):
-        pass
-
-    @abstractmethod
-    def set_credentials(self, credentials: dict):
-        pass
-
-class ApiKeyIntegration(Integration):
-    def __init__(self, name: str, store: Store = None, **kwargs):
-        super().__init__(name, store, **kwargs)
-
-    def get_credentials(self):
-        credentials = self.store.get(self.name)
-        return credentials
-
-    def set_credentials(self, credentials: dict):
-        self.store.set(self.name, credentials)
-
-    def authorize(self):
-        return {"text": "Please configure the environment variable {self.name}_API_KEY"}
-
-
-
-class AgentRIntegration(Integration):
-    def __init__(self, name: str, api_key: str = None, **kwargs):
-        super().__init__(name, **kwargs)
-        self.api_key = api_key or os.getenv("AGENTR_API_KEY")
-        if not self.api_key:
-            logger.error("API key for AgentR is missing. Please visit https://agentr.dev to create an API key, then set it as AGENTR_API_KEY environment variable.")
-            raise ValueError("AgentR API key required - get one at https://agentr.dev")
-
-        self.base_url = "https://auth.agentr.dev"
-        self.user_id = "default"
-    
-    def _create_session_token(self):
-        url = "https://auth.agentr.dev/connect/sessions"
-        body = {
-            "end_user": {
-                "id": self.user_id,
-            },
-            "allowed_integrations": [self.name]
-        }
-        response = httpx.post(url, headers={"Authorization": f"Bearer {self.api_key}"}, json=body)
-        data = response.json()
-        print(data)
-        return data["data"]["token"]
-    
-    def _get_authorize_url(self):
-        session_token = self._create_session_token()
-        return f"https://auth.agentr.dev/oauth/connect/{self.name}?connect_session_token={session_token}"
-    
-    def get_connection_by_owner(self):
-        url = f"https://auth.agentr.dev/connection?endUserId={self.user_id}"
-        response = httpx.get(url, headers={"Authorization": f"Bearer {self.api_key}"})
-        if response.status_code == 200:
-            connections = response.json()["connections"]
-            for connection in connections:
-                if connection["provider_config_key"] == self.name:
-                    return connection["connection_id"]
-        return None
-
-    def set_credentials(self, credentials: dict):
-        raise NotImplementedError("AgentR Integration does not support setting credentials. Visit the authorize url to set credentials.")
-
-    def get_credentials(self):
-        connection_id = self.get_connection_by_owner()
-        logger.info(f"Connection ID: {connection_id}")
-        if connection_id:
-            response = httpx.get(f"{self.base_url}/connection/{connection_id}?provider_config_key={self.name}", headers={"Authorization": f"Bearer {self.api_key}"})
-            data = response.json()
-            return data.get("credentials")
-        return None
-
-    def authorize(self):
-        url = self._get_authorize_url()
-        return f"Please authorize the application by clicking the link {url}"
+from abc import ABC, abstractmethod
+import os
+import sys
+
+from loguru import logger
+from agentr.store import Store
+import httpx
+
+"""
+Integration defines how a Application needs to authorize.
+It is responsible for authenticating application with the service provider.
+Supported integrations:
+- AgentR Integration
+- API Key Integration
+"""
+
+class Integration(ABC):
+    def __init__(self, name: str, store: Store = None):
+        self.name = name
+        self.store = store
+
+    @abstractmethod
+    def authorize(self):
+        pass
+    
+    @abstractmethod
+    def get_credentials(self):
+        pass
+
+    @abstractmethod
+    def set_credentials(self, credentials: dict):
+        pass
+
+class ApiKeyIntegration(Integration):
+    def __init__(self, name: str, store: Store = None, **kwargs):
+        super().__init__(name, store, **kwargs)
+
+    def get_credentials(self):
+        credentials = self.store.get(self.name)
+        return credentials
+
+    def set_credentials(self, credentials: dict):
+        self.store.set(self.name, credentials)
+
+    def authorize(self):
+        return {"text": "Please configure the environment variable {self.name}_API_KEY"}
+
+
+
+class AgentRIntegration(Integration):
+    def __init__(self, name: str, api_key: str = None, **kwargs):
+        super().__init__(name, **kwargs)
+        self.api_key = api_key or os.getenv("AGENTR_API_KEY")
+        if not self.api_key:
+            logger.error("API key for AgentR is missing. Please visit https://agentr.dev to create an API key, then set it as AGENTR_API_KEY environment variable.")
+            raise ValueError("AgentR API key required - get one at https://agentr.dev")
+        self.base_url = os.getenv("AGENTR_BASE_URL", "https://api.agentr.dev")
+    
+    
+    def set_credentials(self, credentials: dict| None = None):
+        return self.authorize()
+        # raise NotImplementedError("AgentR Integration does not support setting credentials. Visit the authorize url to set credentials.")
+
+    def get_credentials(self):
+        response = httpx.get(
+            f"{self.base_url}/api/{self.name}/credentials/",
+            headers={
+                "accept": "application/json",
+                "X-API-KEY": self.api_key
+            }
+        )
+        response.raise_for_status()
+        data = response.json()
+        return data
+
+    def authorize(self):
+        response = httpx.get(
+            f"{self.base_url}/api/{self.name}/authorize/",
+            headers={
+                "X-API-KEY": self.api_key
+            }
+        )
+        response.raise_for_status()
+        url = response.json()
+        return f"Please authorize the application by clicking the link {url}"

agentr/server.py

@@ -1,105 +1,113 @@
-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.integration import AgentRIntegration, ApiKeyIntegration
+from agentr.store import EnvironmentStore, MemoryStore
+from agentr.config import AppConfig, IntegrationConfig, StoreConfig
+from loguru import logger
+import os
+
+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 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,40 @@
-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 LocalServer
+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 = LocalServer(name="Test Server", description="Test Server", apps_list=apps_list)
+
+
+async def test():
+    tools = await mcp.list_tools()
+    from pprint import pprint
+    pprint(tools)
+    result = await mcp.call_tool("star_repository", {"repo_full_name": "manojbajaj95/config"})
+    print(result)
+
+if __name__ == "__main__":
+    import asyncio
     asyncio.run(test())