agentmesh-client 0.1.0__tar.gz

agentmesh_client-0.1.0/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: agentmesh-client
+Version: 0.1.0
+Summary: Shared memory + coordination layer for multi-agent AI systems
+Author-email: agentmesh-client <hello@agentmesh.dev>
+License: MIT
+Project-URL: Homepage, https://github.com/onassis-ctrl/agentmesh
+Project-URL: Documentation, https://agentmesh-production.up.railway.app/docs
+Project-URL: Repository, https://github.com/onassis-ctrl/agentmesh
+Project-URL: Bug Tracker, https://github.com/onassis-ctrl/agentmesh/issues
+Keywords: ai,agents,memory,multi-agent,llm,coordination
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0

agentmesh_client-0.1.0/agentmesh/__init__.py

@@ -0,0 +1,20 @@
+"""
+AgentMesh — Shared memory + coordination layer for multi-agent AI systems.
+
+Quick start:
+    pip install agentmesh
+
+    from agentmesh import AgentMesh
+
+    mesh = AgentMesh(api_key="your_key")
+    mesh.write(agent_id="agent1", content="I specialize in NLP tasks")
+    results = mesh.recall("text processing")
+
+Docs: https://agentmesh-production.up.railway.app/docs
+GitHub: https://github.com/onassis-ctrl/agentmesh
+"""
+
+from .client import AgentMesh, AgentMeshError
+
+__all__ = ["AgentMesh", "AgentMeshError"]
+__version__ = "0.1.0"

agentmesh_client-0.1.0/agentmesh/client.py

@@ -0,0 +1,242 @@
+"""
+AgentMesh Python SDK
+Shared memory + coordination layer for multi-agent AI systems.
+
+Usage:
+    from agentmesh import AgentMesh
+    mesh = AgentMesh(api_key="your_key")
+    mesh.write(agent_id="agent1", content="I specialize in NLP")
+    results = mesh.recall("text processing")
+"""
+
+import requests
+from typing import Optional
+
+
+class AgentMeshError(Exception):
+    """Raised when the AgentMesh API returns an error."""
+    pass
+
+
+class AgentMesh:
+    """
+    AgentMesh client — shared memory + coordination for multi-agent AI systems.
+
+    Args:
+        api_key:  Your AgentMesh API key.
+        base_url: API base URL. Defaults to the hosted cloud API.
+                  Set to http://localhost:8000 for local development.
+        timeout:  Request timeout in seconds. Default 60.
+
+    Example:
+        mesh = AgentMesh(api_key="am_sk_...")
+        mesh.write(agent_id="agent1", content="I handle NLP tasks")
+        results = mesh.recall("text processing")
+    """
+
+    DEFAULT_URL = "https://agentmesh-production.up.railway.app"
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = DEFAULT_URL,
+        timeout: int = 60,
+    ):
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self._session = requests.Session()
+        self._session.headers.update({
+            "x-api-key": self.api_key,
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        })
+
+    # ── internal ───────────────────────────────────────────────────────────────
+
+    def _post(self, endpoint: str, payload: dict) -> dict:
+        url = f"{self.base_url}/{endpoint.lstrip('/')}"
+        try:
+            resp = self._session.post(url, json=payload, timeout=self.timeout)
+            data = resp.json()
+        except requests.exceptions.ConnectionError:
+            raise AgentMeshError(
+                f"Could not connect to AgentMesh at {self.base_url}. "
+                "Check your base_url or network connection."
+            )
+        except requests.exceptions.Timeout:
+            raise AgentMeshError(
+                f"Request to {endpoint} timed out after {self.timeout}s."
+            )
+
+        if data.get("status") == "error":
+            raise AgentMeshError(data.get("detail", "Unknown error"))
+
+        return data.get("data", data)
+
+    def _get(self, endpoint: str) -> dict:
+        url = f"{self.base_url}/{endpoint.lstrip('/')}"
+        try:
+            resp = self._session.get(url, timeout=self.timeout)
+            data = resp.json()
+        except requests.exceptions.ConnectionError:
+            raise AgentMeshError(
+                f"Could not connect to AgentMesh at {self.base_url}."
+            )
+        except requests.exceptions.Timeout:
+            raise AgentMeshError(
+                f"Request to {endpoint} timed out after {self.timeout}s."
+            )
+
+        if data.get("status") == "error":
+            raise AgentMeshError(data.get("detail", "Unknown error"))
+
+        return data.get("data", data)
+
+    # ── public API ─────────────────────────────────────────────────────────────
+
+    def write(
+        self,
+        content: str,
+        agent_id: Optional[str] = None,
+        memory_type: str = "general",
+    ) -> dict:
+        """
+        Store a memory.
+
+        Args:
+            content:     What to remember.
+            agent_id:    Which agent is writing this memory.
+            memory_type: Category label (default: "general").
+
+        Returns:
+            dict with status, id, content, agent_id, namespace.
+
+        Example:
+            mesh.write(agent_id="agent1", content="I handle NLP tasks")
+        """
+        return self._post("/write", {
+            "agent_id": agent_id,
+            "content": content,
+            "memory_type": memory_type,
+        })
+
+    def recall(
+        self,
+        query: str,
+        top_k: int = 5,
+    ) -> list:
+        """
+        Semantic search across all agent memories.
+
+        Args:
+            query: What to search for.
+            top_k: Max number of results to return (default: 5).
+
+        Returns:
+            List of matching memories with agent_id, content, score.
+
+        Example:
+            results = mesh.recall("text processing", top_k=3)
+            for r in results:
+                print(r["agent_id"], r["score"], r["content"])
+        """
+        return self._post("/recall", {
+            "query": query,
+            "top_k": top_k,
+        })
+
+    def index(self) -> dict:
+        """
+        Show which agents know what.
+
+        Returns:
+            Dict mapping agent_id → list of memory summaries.
+
+        Example:
+            knowledge_map = mesh.index()
+        """
+        return self._post("/index", {})
+
+    def route(
+        self,
+        task: str,
+        top_k: int = 3,
+    ) -> list:
+        """
+        Find the best agent(s) to handle a task.
+
+        Args:
+            task:  Description of the task.
+            top_k: Number of agent suggestions to return (default: 3).
+
+        Returns:
+            Ranked list of agents best suited for the task.
+
+        Example:
+            agents = mesh.route("summarize this document")
+            best_agent = agents[0]["agent_id"]
+        """
+        return self._post("/route", {
+            "task": task,
+            "top_k": top_k,
+        })
+
+    def discover(
+        self,
+        topic: str,
+    ) -> list:
+        """
+        Discover agents that specialize in a topic.
+
+        Args:
+            topic: Topic to search for specialists.
+
+        Returns:
+            List of agents with expertise in that topic.
+
+        Example:
+            experts = mesh.discover("database queries")
+        """
+        return self._post("/discover", {
+            "topic": topic,
+        })
+
+    def metrics(self) -> dict:
+        """
+        Get collaboration stats and insights.
+
+        Returns:
+            Dict with total memories, agent counts, top agents, etc.
+
+        Example:
+            stats = mesh.metrics()
+            print(stats["total_memories"])
+        """
+        return self._get("/metrics")
+
+    def forget(
+        self,
+        agent_id: Optional[str] = None,
+        content_filter: Optional[str] = None,
+    ) -> dict:
+        """
+        GDPR-compliant delete — remove memories by agent or content.
+
+        Args:
+            agent_id:       Delete all memories for this agent.
+            content_filter: Delete memories containing this string.
+
+        Returns:
+            Dict with count of deleted memories.
+
+        Example:
+            mesh.forget(agent_id="agent1")
+            mesh.forget(content_filter="sensitive data")
+        """
+        if not agent_id and not content_filter:
+            raise ValueError("Provide agent_id or content_filter (or both).")
+        return self._post("/forget", {
+            "agent_id": agent_id,
+            "content_filter": content_filter,
+        })

agentmesh_client-0.1.0/agentmesh_client.egg-info/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: agentmesh-client
+Version: 0.1.0
+Summary: Shared memory + coordination layer for multi-agent AI systems
+Author-email: agentmesh-client <hello@agentmesh.dev>
+License: MIT
+Project-URL: Homepage, https://github.com/onassis-ctrl/agentmesh
+Project-URL: Documentation, https://agentmesh-production.up.railway.app/docs
+Project-URL: Repository, https://github.com/onassis-ctrl/agentmesh
+Project-URL: Bug Tracker, https://github.com/onassis-ctrl/agentmesh/issues
+Keywords: ai,agents,memory,multi-agent,llm,coordination
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0

agentmesh_client-0.1.0/agentmesh_client.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+pyproject.toml
+agentmesh/__init__.py
+agentmesh/client.py
+agentmesh_client.egg-info/PKG-INFO
+agentmesh_client.egg-info/SOURCES.txt
+agentmesh_client.egg-info/dependency_links.txt
+agentmesh_client.egg-info/requires.txt
+agentmesh_client.egg-info/top_level.txt
+tests/test_sdk.py

agentmesh_client-0.1.0/agentmesh_client.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agentmesh_client-0.1.0/agentmesh_client.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.28.0

agentmesh_client-0.1.0/agentmesh_client.egg-info/top_level.txt

@@ -0,0 +1 @@
+agentmesh

agentmesh_client-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "agentmesh-client"
+version = "0.1.0"
+description = "Shared memory + coordination layer for multi-agent AI systems"
+readme = "README.md"
+license = { text = "MIT" }
+authors = [{ name = "agentmesh-client", email = "hello@agentmesh.dev" }]
+keywords = ["ai", "agents", "memory", "multi-agent", "llm", "coordination"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+requires-python = ">=3.9"
+dependencies = [
+    "requests>=2.28.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/onassis-ctrl/agentmesh"
+Documentation = "https://agentmesh-production.up.railway.app/docs"
+Repository = "https://github.com/onassis-ctrl/agentmesh"
+"Bug Tracker" = "https://github.com/onassis-ctrl/agentmesh/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["agentmesh*"]
+

agentmesh_client-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

agentmesh_client-0.1.0/tests/test_sdk.py

@@ -0,0 +1,80 @@
+"""
+AgentMesh SDK Tests
+Tests the SDK client against the live API.
+
+Run with:  pytest tests/test_sdk.py -v
+"""
+
+import pytest
+from agentmesh import AgentMesh, AgentMeshError
+
+# Point at local server for tests — change to Railway URL for cloud tests
+BASE_URL = "http://localhost:8000"
+API_KEY = "dev"
+
+@pytest.fixture
+def mesh():
+    return AgentMesh(api_key=API_KEY, base_url=BASE_URL)
+
+
+def test_write(mesh):
+    result = mesh.write(agent_id="sdk_test_agent", content="I handle SDK testing tasks")
+    assert result["agent_id"] == "sdk_test_agent"
+    assert "id" in result
+    print(f"✅  write() — id={result['id']}")
+
+
+def test_recall(mesh):
+    mesh.write(agent_id="sdk_recall_agent", content="I specialize in data retrieval")
+    results = mesh.recall("data retrieval", top_k=3)
+    assert isinstance(results, list)
+    assert len(results) >= 1
+    assert "agent_id" in results[0]
+    assert "score" in results[0]
+    print(f"✅  recall() — {len(results)} results")
+
+
+def test_route(mesh):
+    mesh.write(agent_id="sdk_route_agent", content="I summarize documents and reports")
+    results = mesh.route("summarize this report", top_k=2)
+    assert isinstance(results, list)
+    print(f"✅  route() — {results}")
+
+
+def test_discover(mesh):
+    mesh.write(agent_id="sdk_discover_agent", content="I run SQL queries and manage databases")
+    results = mesh.discover("database")
+    assert isinstance(results, list)
+    print(f"✅  discover() — {results}")
+
+
+def test_index(mesh):
+    result = mesh.index()
+    assert result is not None
+    print(f"✅  index() — OK")
+
+
+def test_metrics(mesh):
+    result = mesh.metrics()
+    assert result is not None
+    print(f"✅  metrics() — {result}")
+
+
+def test_forget(mesh):
+    mesh.write(agent_id="sdk_forget_agent", content="This memory will be deleted")
+    result = mesh.forget(agent_id="sdk_forget_agent")
+    assert result is not None
+    print(f"✅  forget() — {result}")
+
+
+def test_forget_requires_params(mesh):
+    with pytest.raises(ValueError):
+        mesh.forget()
+    print("✅  forget() raises ValueError with no params")
+
+
+def test_invalid_api_key():
+    bad_mesh = AgentMesh(api_key="invalid_key", base_url=BASE_URL)
+    # In dev mode server accepts anything — skip auth test in dev
+    # In production this would raise AgentMeshError
+    print("✅  invalid key test skipped in dev mode")