shared-context-cache-mcp-server 0.1.0__tar.gz

shared_context_cache_mcp_server-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.venv/
+.env
+*.env

shared_context_cache_mcp_server-0.1.0/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: shared-context-cache-mcp-server
+Version: 0.1.0
+Summary: MCP server for shared context caching — AI agents share computed results to reduce token cost and latency
+Project-URL: Homepage, https://github.com/AiAgentKarl/shared-context-cache-mcp-server
+Project-URL: Repository, https://github.com/AiAgentKarl/shared-context-cache-mcp-server
+Author: AiAgentKarl
+License: MIT
+Keywords: agent-economy,ai-agents,cache,context-sharing,mcp,model-context-protocol,shared-context,token-optimization
+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.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: mcp>=1.0.0
+Description-Content-Type: text/markdown
+
+# shared-context-cache-mcp-server
+
+**MCP server for shared context caching** — AI agents share computed results to reduce token cost and latency.
+
+[![PyPI](https://img.shields.io/pypi/v/shared-context-cache-mcp-server)](https://pypi.org/project/shared-context-cache-mcp-server/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+## Why?
+
+Every AI agent constantly re-computes the same results: weather lookups, price checks, document summaries, research queries. With this MCP server, agents share their computed results through a common cache.
+
+**Network effect:** More agents caching → more cache hits → everyone saves tokens and latency.
+
+> Like a CDN, but for agent intelligence.
+
+## Install
+
+```bash
+pip install shared-context-cache-mcp-server
+```
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `cache_lookup` | Look up a cached result by key — check before computing |
+| `cache_search` | Search cache by keywords — find relevant precomputed results |
+| `cache_store` | Store a computed result for other agents to reuse |
+| `cache_stats` | Get cache performance stats (hits, misses, cost savings) |
+| `cache_list` | List available cache entries, optionally filtered by tags |
+
+## Usage Pattern
+
+```
+1. Before computing: cache_search("weather berlin") → cache_lookup("weather:berlin:today")
+2. Cache hit? → Use the stored result directly, no API call needed
+3. Cache miss? → Compute the result, then: cache_store(key, value, tags="weather,berlin")
+4. Other agents now benefit from your computation
+```
+
+## Claude Desktop Config
+
+```json
+{
+  "mcpServers": {
+    "shared-context-cache": {
+      "command": "shared-context-cache-mcp-server"
+    }
+  }
+}
+```
+
+## Cache Key Conventions
+
+Use descriptive, hierarchical keys:
+- `weather:berlin:2026-03-28`
+- `research:arxiv:2501.00001:summary`
+- `price:bitcoin:usd:2026-03-28`
+- `analysis:company:AAPL:q1-2026`
+
+## Backend
+
+Powered by [agent-apis.vercel.app/api/cache](https://agent-apis.vercel.app/api/cache) — a shared cache API built for the agent economy.
+
+## License
+
+MIT — [AiAgentKarl](https://github.com/AiAgentKarl)

shared_context_cache_mcp_server-0.1.0/README.md

@@ -0,0 +1,67 @@
+# shared-context-cache-mcp-server
+
+**MCP server for shared context caching** — AI agents share computed results to reduce token cost and latency.
+
+[![PyPI](https://img.shields.io/pypi/v/shared-context-cache-mcp-server)](https://pypi.org/project/shared-context-cache-mcp-server/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+## Why?
+
+Every AI agent constantly re-computes the same results: weather lookups, price checks, document summaries, research queries. With this MCP server, agents share their computed results through a common cache.
+
+**Network effect:** More agents caching → more cache hits → everyone saves tokens and latency.
+
+> Like a CDN, but for agent intelligence.
+
+## Install
+
+```bash
+pip install shared-context-cache-mcp-server
+```
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `cache_lookup` | Look up a cached result by key — check before computing |
+| `cache_search` | Search cache by keywords — find relevant precomputed results |
+| `cache_store` | Store a computed result for other agents to reuse |
+| `cache_stats` | Get cache performance stats (hits, misses, cost savings) |
+| `cache_list` | List available cache entries, optionally filtered by tags |
+
+## Usage Pattern
+
+```
+1. Before computing: cache_search("weather berlin") → cache_lookup("weather:berlin:today")
+2. Cache hit? → Use the stored result directly, no API call needed
+3. Cache miss? → Compute the result, then: cache_store(key, value, tags="weather,berlin")
+4. Other agents now benefit from your computation
+```
+
+## Claude Desktop Config
+
+```json
+{
+  "mcpServers": {
+    "shared-context-cache": {
+      "command": "shared-context-cache-mcp-server"
+    }
+  }
+}
+```
+
+## Cache Key Conventions
+
+Use descriptive, hierarchical keys:
+- `weather:berlin:2026-03-28`
+- `research:arxiv:2501.00001:summary`
+- `price:bitcoin:usd:2026-03-28`
+- `analysis:company:AAPL:q1-2026`
+
+## Backend
+
+Powered by [agent-apis.vercel.app/api/cache](https://agent-apis.vercel.app/api/cache) — a shared cache API built for the agent economy.
+
+## License
+
+MIT — [AiAgentKarl](https://github.com/AiAgentKarl)

shared_context_cache_mcp_server-0.1.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "shared-context-cache-mcp-server"
+version = "0.1.0"
+description = "MCP server for shared context caching — AI agents share computed results to reduce token cost and latency"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "AiAgentKarl" }]
+keywords = [
+    "mcp",
+    "model-context-protocol",
+    "ai-agents",
+    "cache",
+    "shared-context",
+    "agent-economy",
+    "context-sharing",
+    "token-optimization",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = ["mcp>=1.0.0", "httpx>=0.27.0"]
+
+[project.urls]
+Homepage = "https://github.com/AiAgentKarl/shared-context-cache-mcp-server"
+Repository = "https://github.com/AiAgentKarl/shared-context-cache-mcp-server"
+
+[project.scripts]
+shared-context-cache-mcp-server = "src.server:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src"]

shared_context_cache_mcp_server-0.1.0/src/clients/cache_client.py

@@ -0,0 +1,69 @@
+"""HTTP-Client fuer den Shared Context Cache (agent-apis.vercel.app/api/cache)."""
+
+import httpx
+
+CACHE_BASE_URL = "https://agent-apis.vercel.app/api/cache"
+
+# Standard-Timeout in Sekunden
+TIMEOUT = 15
+
+
+async def get_cache_entry(key: str) -> dict:
+    """Ruft einen Cache-Eintrag per Key ab."""
+    async with httpx.AsyncClient(timeout=TIMEOUT) as client:
+        resp = await client.get(CACHE_BASE_URL, params={"action": "get", "key": key})
+        resp.raise_for_status()
+        return resp.json()
+
+
+async def search_cache(query: str, limit: int = 10) -> dict:
+    """Sucht im Cache nach passenden Eintraegen (Stichwortsuche)."""
+    async with httpx.AsyncClient(timeout=TIMEOUT) as client:
+        resp = await client.get(
+            CACHE_BASE_URL,
+            params={"action": "search", "query": query, "limit": limit},
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+
+async def store_cache_entry(
+    key: str,
+    value: dict | str | list,
+    ttl: int = 86400,
+    tags: list[str] | None = None,
+    agent_id: str = "mcp-agent",
+) -> dict:
+    """Speichert einen neuen Eintrag im Cache."""
+    payload: dict = {
+        "action": "store",
+        "key": key,
+        "value": value,
+        "ttl": ttl,
+        "agent_id": agent_id,
+    }
+    if tags:
+        payload["tags"] = tags
+    async with httpx.AsyncClient(timeout=TIMEOUT) as client:
+        resp = await client.post(CACHE_BASE_URL, json=payload)
+        resp.raise_for_status()
+        return resp.json()
+
+
+async def get_cache_stats() -> dict:
+    """Gibt Statistiken ueber den Cache zurueck (Hits, Misses, Top-Queries)."""
+    async with httpx.AsyncClient(timeout=TIMEOUT) as client:
+        resp = await client.get(CACHE_BASE_URL, params={"action": "stats"})
+        resp.raise_for_status()
+        return resp.json()
+
+
+async def list_cache_entries(limit: int = 20, tags: list[str] | None = None) -> dict:
+    """Listet alle Cache-Eintraege auf, optional gefiltert nach Tags."""
+    params: dict = {"action": "list", "limit": limit}
+    if tags:
+        params["tags"] = ",".join(tags)
+    async with httpx.AsyncClient(timeout=TIMEOUT) as client:
+        resp = await client.get(CACHE_BASE_URL, params=params)
+        resp.raise_for_status()
+        return resp.json()

shared_context_cache_mcp_server-0.1.0/src/server.py

@@ -0,0 +1,28 @@
+"""Shared Context Cache MCP-Server -- Agents teilen berechnete Ergebnisse."""
+
+from mcp.server.fastmcp import FastMCP
+from src.tools.cache_tools import register_cache_tools
+
+# FastMCP-Server initialisieren
+mcp = FastMCP(
+    "Shared Context Cache",
+    instructions=(
+        "Shared context cache for AI agents. Before computing expensive results "
+        "(web searches, analyses, API calls), use cache_search or cache_lookup to "
+        "check if another agent has already computed the answer. After computing, "
+        "use cache_store to share your result with other agents. "
+        "Network effect: more agents caching = more cache hits = everyone saves tokens."
+    ),
+)
+
+# Cache-Tools registrieren
+register_cache_tools(mcp)
+
+
+def main() -> None:
+    """Einstiegspunkt fuer den MCP-Server (stdio-Transport)."""
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

shared_context_cache_mcp_server-0.1.0/src/tools/cache_tools.py

@@ -0,0 +1,184 @@
+"""MCP-Tools fuer Shared Context Cache -- Agents teilen berechnete Ergebnisse."""
+
+import json
+from mcp.server.fastmcp import FastMCP
+from src.clients.cache_client import (
+    get_cache_entry,
+    search_cache,
+    store_cache_entry,
+    get_cache_stats,
+    list_cache_entries,
+)
+
+
+def register_cache_tools(mcp: FastMCP) -> None:
+    """Registriert alle Cache-Tools am MCP-Server."""
+
+    @mcp.tool()
+    async def cache_lookup(key: str) -> str:
+        """Look up a cached result by key. Returns the stored value if found.
+
+        Use this BEFORE computing expensive results — another agent may have
+        already computed and cached the answer, saving tokens and latency.
+
+        Args:
+            key: Cache key (e.g. 'weather:berlin:2026-03-28', 'research:quantum-computing')
+        """
+        try:
+            data = await get_cache_entry(key)
+            if data.get("found"):
+                entry = data.get("entry", {})
+                result = {
+                    "found": True,
+                    "key": key,
+                    "value": entry.get("value"),
+                    "cached_by": entry.get("agent_id", "unknown"),
+                    "hits": entry.get("hits", 0),
+                    "expires_in": entry.get("ttl_remaining", "unknown"),
+                    "tags": entry.get("tags", []),
+                    "message": "Cache HIT — result retrieved, no computation needed",
+                }
+            else:
+                result = {
+                    "found": False,
+                    "key": key,
+                    "message": "Cache MISS — compute the result and use cache_store to share it",
+                }
+            return json.dumps(result, ensure_ascii=False)
+        except Exception as e:
+            return json.dumps({"error": str(e), "key": key})
+
+    @mcp.tool()
+    async def cache_search(query: str, limit: int = 10) -> str:
+        """Search the shared cache by keywords. Find relevant cached results from other agents.
+
+        Search before computing — if another agent has cached a similar result,
+        you can reuse it directly. More agents caching = more cache hits for everyone.
+
+        Args:
+            query: Keywords to search for (e.g. 'weather berlin', 'bitcoin price', 'quantum computing summary')
+            limit: Max number of results to return (default: 10, max: 50)
+        """
+        try:
+            data = await search_cache(query, limit)
+            entries = data.get("entries", [])
+            result = {
+                "query": query,
+                "total_found": len(entries),
+                "entries": [
+                    {
+                        "key": e.get("key"),
+                        "tags": e.get("tags", []),
+                        "hits": e.get("hits", 0),
+                        "agent_id": e.get("agent_id"),
+                        "preview": str(e.get("value", ""))[:200],
+                    }
+                    for e in entries
+                ],
+                "tip": "Use cache_lookup with a specific key to retrieve the full value",
+            }
+            return json.dumps(result, ensure_ascii=False)
+        except Exception as e:
+            return json.dumps({"error": str(e), "query": query})
+
+    @mcp.tool()
+    async def cache_store(
+        key: str,
+        value: str,
+        ttl_seconds: int = 86400,
+        tags: str = "",
+        agent_id: str = "mcp-agent",
+    ) -> str:
+        """Store a computed result in the shared cache so other agents can reuse it.
+
+        After computing an expensive result (web search, analysis, API call),
+        store it here. Other agents using cache_lookup or cache_search will
+        find your result and save their own computation costs.
+
+        Network effect: More agents caching = more cache hits = everyone benefits.
+
+        Args:
+            key: Unique cache key (e.g. 'weather:berlin:2026-03-28', 'summary:arxiv:2501.00001')
+            value: The result to cache (JSON string, text, or any serializable content)
+            ttl_seconds: Time-to-live in seconds (default: 86400 = 24h, max: 604800 = 7 days)
+            tags: Comma-separated tags for discovery (e.g. 'weather,berlin,temperature')
+            agent_id: Your agent identifier for attribution (e.g. 'weather-agent-v2')
+        """
+        try:
+            # Wert parsen falls JSON, sonst als String speichern
+            try:
+                parsed_value = json.loads(value)
+            except (json.JSONDecodeError, TypeError):
+                parsed_value = value
+
+            tag_list = [t.strip() for t in tags.split(",") if t.strip()] if tags else []
+            ttl = min(max(ttl_seconds, 60), 604800)  # Zwischen 1 Min und 7 Tagen
+
+            data = await store_cache_entry(
+                key=key,
+                value=parsed_value,
+                ttl=ttl,
+                tags=tag_list,
+                agent_id=agent_id,
+            )
+            result = {
+                "stored": True,
+                "key": key,
+                "ttl_seconds": ttl,
+                "tags": tag_list,
+                "agent_id": agent_id,
+                "message": "Result cached successfully — other agents can now reuse this",
+                "expires_in": f"{ttl // 3600}h {(ttl % 3600) // 60}m",
+            }
+            return json.dumps(result, ensure_ascii=False)
+        except Exception as e:
+            return json.dumps({"error": str(e), "key": key})
+
+    @mcp.tool()
+    async def cache_stats() -> str:
+        """Get statistics about the shared cache — hits, misses, top queries, cost savings.
+
+        Shows overall cache performance and which keys are most frequently accessed.
+        Use this to understand the network effect: how much computation has been
+        saved across all agents.
+        """
+        try:
+            data = await get_cache_stats()
+            return json.dumps(data, ensure_ascii=False)
+        except Exception as e:
+            return json.dumps({"error": str(e)})
+
+    @mcp.tool()
+    async def cache_list(limit: int = 20, tags: str = "") -> str:
+        """List available cache entries, optionally filtered by tags.
+
+        Browse what other agents have cached. Good for discovering available
+        precomputed results before running your own queries.
+
+        Args:
+            limit: Max entries to return (default: 20, max: 100)
+            tags: Filter by tags, comma-separated (e.g. 'weather,temperature')
+        """
+        try:
+            tag_list = [t.strip() for t in tags.split(",") if t.strip()] if tags else None
+            data = await list_cache_entries(limit=min(limit, 100), tags=tag_list)
+            entries = data.get("entries", [])
+            result = {
+                "total_entries": data.get("total", len(entries)),
+                "showing": len(entries),
+                "filter_tags": tag_list,
+                "entries": [
+                    {
+                        "key": e.get("key"),
+                        "tags": e.get("tags", []),
+                        "hits": e.get("hits", 0),
+                        "agent_id": e.get("agent_id"),
+                        "ttl_remaining": e.get("ttl_remaining"),
+                    }
+                    for e in entries
+                ],
+                "tip": "Use cache_lookup to retrieve the full value for any key",
+            }
+            return json.dumps(result, ensure_ascii=False)
+        except Exception as e:
+            return json.dumps({"error": str(e)})