agentr 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

agentr/integration.py

@@ -0,0 +1,98 @@
+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}"

agentr/server.py

@@ -1,33 +1,105 @@
-from abc import ABC, abstractmethod
-from mcp.server.fastmcp import FastMCP
-
-from agentr.applications.zenquotes.app import ZenQuoteApp
-from agentr.store import Store
-
-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, store: Store, **kwargs):
-        self.store = store
-        super().__init__(name, description, **kwargs)
-
-
-class TestServer(Server):
-    """
-    Test server for development purposes
-    """
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        self.apps_list = ["zenquotes"]
-        self.__load_apps()
-
-    def __load_apps(self):
-        self.apps = []
-        for app in self.apps_list:
-            if app == "zenquotes":
-                app = ZenQuoteApp(store=self.store)
-                tools = app.list_tools()
-                self.add_tool(tools[0])
+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)
+
+                

agentr/store.py

@@ -1,35 +1,71 @@
-
-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]
-
+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

@@ -0,0 +1,38 @@
+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
+    asyncio.run(test())