ctxstore-mcp 1.0.0__tar.gz

ctxstore_mcp-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ctxstore.ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ctxstore_mcp-1.0.0/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: ctxstore-mcp
+Version: 1.0.0
+Summary: Persistent AI memory via MCP. Give your AI agent long-term memory in 30 seconds.
+Author-email: "ctxstore.ai" <hello@ctxstore.ai>
+License-Expression: MIT
+Project-URL: Homepage, https://ctxstore.ai
+Project-URL: Documentation, https://ctxstore.ai/docs
+Project-URL: Repository, https://github.com/ctxstore-ai/ctxstore-mcp
+Project-URL: Bug Tracker, https://github.com/ctxstore-ai/ctxstore-mcp/issues
+Keywords: mcp,ai,memory,context,vector,llm,claude,cursor
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: httpx>=0.25.0
+Dynamic: license-file
+
+# ctxstore-mcp

ctxstore_mcp-1.0.0/README.md

@@ -0,0 +1 @@
+# ctxstore-mcp

ctxstore_mcp-1.0.0/ctxstore_mcp/__init__.py

@@ -0,0 +1,15 @@
+"""
+ctxstore-mcp — Persistent AI memory via MCP.
+
+Thin MCP server that proxies to the ctxstore.ai API.
+All embedding and storage happens server-side.
+"""
+
+import asyncio
+
+from .server import main as _main
+
+
+def main():
+    """CLI entry point."""
+    asyncio.run(_main())

ctxstore_mcp-1.0.0/ctxstore_mcp/__main__.py

@@ -0,0 +1,4 @@
+"""Allow running as: python -m ctxstore_mcp"""
+from . import main
+
+main()

ctxstore_mcp-1.0.0/ctxstore_mcp/auth.py

@@ -0,0 +1,120 @@
+"""
+ctxstore credential management — auto-provisioning and credential caching.
+
+Flow:
+  1. Check TENANT_API_KEY env var (always wins)
+  2. Check ~/.ctxstore/credentials.json
+  3. POST /api/v1/provision to get a free key, save it
+"""
+
+import json
+import logging
+import os
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+import httpx
+
+logger = logging.getLogger("ctxstore.auth")
+
+CREDENTIALS_FILE = Path.home() / ".ctxstore" / "credentials.json"
+CTXSTORE_URL = os.getenv("CTXSTORE_URL", "https://ctxstore.ai").rstrip("/")
+PROVISION_URL = f"{CTXSTORE_URL}/api/v1/provision"
+
+
+def load_credentials() -> Optional[dict]:
+    """Load saved credentials from disk. Returns None if not found or invalid."""
+    if not CREDENTIALS_FILE.exists():
+        return None
+    try:
+        with open(CREDENTIALS_FILE) as f:
+            data = json.load(f)
+        if data.get("api_key"):
+            return data
+    except (json.JSONDecodeError, OSError):
+        pass
+    return None
+
+
+def save_credentials(api_key: str, tenant_id: str = "") -> None:
+    """Save credentials to ~/.ctxstore/credentials.json with 600 permissions."""
+    CREDENTIALS_FILE.parent.mkdir(parents=True, exist_ok=True)
+    data = {
+        "api_key": api_key,
+        "tenant_id": tenant_id,
+        "provisioned_at": datetime.now(timezone.utc).isoformat(),
+    }
+    with open(CREDENTIALS_FILE, "w") as f:
+        json.dump(data, f, indent=2)
+        f.write("\n")
+    CREDENTIALS_FILE.chmod(0o600)
+
+
+def provision() -> str:
+    """
+    Call the ctxstore.ai provision endpoint to get a free API key.
+    Saves credentials to disk and prints a friendly first-run message.
+    Returns the api_key string.
+    """
+    print(
+        "\n✦ ctxstore.ai: provisioning your free memory account...",
+        file=sys.stderr,
+    )
+    try:
+        resp = httpx.post(
+            PROVISION_URL,
+            json={"source": "ctxstore-mcp"},
+            timeout=15.0,
+        )
+        resp.raise_for_status()
+        data = resp.json()
+    except httpx.HTTPError as e:
+        raise RuntimeError(
+            f"Could not provision ctxstore.ai account: {e}\n"
+            f"Set TENANT_API_KEY manually or visit {CTXSTORE_URL}"
+        ) from e
+
+    api_key = data.get("api_key", "")
+    tenant_id = data.get("tenant_id", "")
+
+    if not api_key:
+        raise RuntimeError(
+            f"Provisioning response missing api_key. "
+            f"Visit {CTXSTORE_URL} to get your key."
+        )
+
+    save_credentials(api_key, tenant_id)
+    print(
+        f"✓ ctxstore.ai: account provisioned! Key saved to {CREDENTIALS_FILE}",
+        file=sys.stderr,
+    )
+    return api_key
+
+
+def get_or_provision() -> str:
+    """
+    Return the API key, auto-provisioning if needed.
+
+    Priority:
+      1. TENANT_API_KEY environment variable
+      2. ~/.ctxstore/credentials.json
+      3. Auto-provision via ctxstore.ai (free, no signup)
+    """
+    # 1. Env var always wins
+    env_key = os.getenv("TENANT_API_KEY", "").strip()
+    if env_key:
+        return env_key
+
+    # 2. Saved credentials
+    creds = load_credentials()
+    if creds:
+        return creds["api_key"]
+
+    # 3. Auto-provision
+    return provision()
+
+
+# Alias for server.py import
+resolve_api_key = get_or_provision

ctxstore_mcp-1.0.0/ctxstore_mcp/server.py

@@ -0,0 +1,303 @@
+"""
+ctxstore MCP Server — thin client that proxies to ctxstore.ai API.
+
+All embedding generation and vector storage happens server-side.
+This package just translates MCP tool calls to HTTP API calls.
+
+Environment variables:
+  TENANT_API_KEY  — Your ctxstore.ai API key (required)
+  CTXSTORE_URL    — API base URL (default: https://ctxstore.ai)
+"""
+
+import logging
+import os
+import sys
+from typing import Any
+
+import httpx
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+from mcp.types import TextContent, Tool
+
+from .auth import resolve_api_key
+
+logger = logging.getLogger("ctxstore.mcp")
+
+BASE_URL = os.getenv("CTXSTORE_URL", "https://ctxstore.ai").rstrip("/")
+
+# Resolved lazily on first use so startup auto-provision prints before the
+# server enters the stdio event loop.
+_API_KEY: str | None = None
+
+
+def _get_api_key() -> str:
+    global _API_KEY
+    if _API_KEY is None:
+        _API_KEY = resolve_api_key()
+    return _API_KEY
+
+app = Server("ctxstore")
+
+
+def _headers() -> dict:
+    return {
+        "Authorization": f"Bearer {_get_api_key()}",
+        "Content-Type": "application/json",
+        "User-Agent": "ctxstore-mcp/1.0.0",
+    }
+
+
+async def _api(method: str, path: str, json: dict = None) -> dict:
+    """Make an authenticated API call to ctxstore.ai."""
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        resp = await client.request(
+            method,
+            f"{BASE_URL}{path}",
+            headers=_headers(),
+            json=json,
+        )
+        if resp.status_code == 401:
+            return {"error": "Invalid API key. Check your TENANT_API_KEY."}
+        if resp.status_code == 429:
+            return {"error": "Rate limit reached. Upgrade your plan at ctxstore.ai."}
+        if resp.status_code >= 400:
+            try:
+                return resp.json()
+            except Exception:
+                return {"error": f"API error: {resp.status_code}"}
+        return resp.json()
+
+
+@app.list_tools()
+async def list_tools() -> list[Tool]:
+    return [
+        Tool(
+            name="search_context",
+            description=(
+                "Search memory — all ingested conversations and sessions. "
+                "Returns semantically relevant context with temporal weighting "
+                "(recent = higher rank)."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "Natural language search query",
+                    },
+                    "top_k": {
+                        "type": "integer",
+                        "description": "Number of results (default 20, max 100)",
+                        "default": 20,
+                    },
+                    "source": {
+                        "type": "string",
+                        "description": "Filter by source: 'chatgpt' or 'claude'",
+                        "enum": ["chatgpt", "claude"],
+                    },
+                    "days_back": {
+                        "type": "integer",
+                        "description": "Only search within last N days",
+                    },
+                },
+                "required": ["query"],
+            },
+        ),
+        Tool(
+            name="search_facts",
+            description=(
+                "Search extracted facts, preferences, and decisions. "
+                "Facts are tagged by category: preference, decision, identity, "
+                "technical, relationship. Permanent facts bypass temporal decay."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "What to search for",
+                    },
+                    "category": {
+                        "type": "string",
+                        "description": "Filter by category",
+                        "enum": ["preference", "decision", "identity", "technical", "relationship"],
+                    },
+                    "top_k": {
+                        "type": "integer",
+                        "description": "Number of results",
+                        "default": 10,
+                    },
+                },
+                "required": ["query"],
+            },
+        ),
+        Tool(
+            name="store_fact",
+            description=(
+                "Store a new fact for permanent retention. Use this when the user "
+                "states a preference, makes a decision, or shares information that "
+                "should persist across sessions."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "text": {
+                        "type": "string",
+                        "description": "The fact to store",
+                    },
+                    "category": {
+                        "type": "string",
+                        "description": "Fact category",
+                        "enum": ["preference", "decision", "identity", "technical", "relationship"],
+                    },
+                    "is_permanent": {
+                        "type": "boolean",
+                        "description": "Whether this fact should bypass temporal decay",
+                        "default": True,
+                    },
+                },
+                "required": ["text", "category"],
+            },
+        ),
+        Tool(
+            name="delete_fact",
+            description="Delete a stored fact by its ID.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "fact_id": {
+                        "type": "string",
+                        "description": "The UUID of the fact to delete",
+                    },
+                },
+                "required": ["fact_id"],
+            },
+        ),
+        Tool(
+            name="get_stats",
+            description=(
+                "Get statistics about your context store — total vectors, "
+                "collection sizes, usage vs plan limits."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {},
+            },
+        ),
+    ]
+
+
+@app.call_tool()
+async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
+    if not _get_api_key():
+        return [TextContent(
+            type="text",
+            text="No API key configured. Set TENANT_API_KEY in your MCP config. "
+                 "Get a free key at https://ctxstore.ai",
+        )]
+
+    if name == "search_context":
+        result = await _api("POST", "/api/v1/search", {
+            "query": arguments["query"],
+            "top_k": arguments.get("top_k", 20),
+            "source": arguments.get("source"),
+            "days_back": arguments.get("days_back"),
+        })
+        if "error" in result:
+            return [TextContent(type="text", text=result["error"])]
+        return [TextContent(type="text", text=_format_search_results(result))]
+
+    elif name == "search_facts":
+        result = await _api("POST", "/api/v1/facts/search", {
+            "query": arguments["query"],
+            "category": arguments.get("category"),
+            "top_k": arguments.get("top_k", 10),
+        })
+        if "error" in result:
+            return [TextContent(type="text", text=result["error"])]
+        return [TextContent(type="text", text=_format_fact_results(result))]
+
+    elif name == "store_fact":
+        result = await _api("POST", "/api/v1/facts", {
+            "text": arguments["text"],
+            "category": arguments["category"],
+            "is_permanent": arguments.get("is_permanent", True),
+        })
+        if "error" in result:
+            return [TextContent(type="text", text=result["error"])]
+        return [TextContent(
+            type="text",
+            text=f"Fact stored (id={result.get('fact_id', '?')}, "
+                 f"category={arguments['category']}, "
+                 f"permanent={arguments.get('is_permanent', True)}): "
+                 f"{arguments['text']}",
+        )]
+
+    elif name == "delete_fact":
+        result = await _api("DELETE", f"/api/v1/facts/{arguments['fact_id']}")
+        if "error" in result:
+            return [TextContent(type="text", text=result["error"])]
+        return [TextContent(type="text", text=f"Fact {arguments['fact_id']} deleted.")]
+
+    elif name == "get_stats":
+        result = await _api("GET", "/api/v1/stats")
+        if "error" in result:
+            return [TextContent(type="text", text=result["error"])]
+        return [TextContent(type="text", text=_format_stats(result))]
+
+    return [TextContent(type="text", text=f"Unknown tool: {name}")]
+
+
+def _format_search_results(data: dict) -> str:
+    results = data.get("results", [])
+    if not results:
+        return "No relevant context found."
+    formatted = []
+    for r in results:
+        header = f"[{r.get('source', '?')}|{r.get('age', '?')}|score:{r.get('score', 0):.3f}]"
+        title = r.get("conversation_title", "")
+        if title:
+            header += f" ({title})"
+        formatted.append(f"{header}\n{r.get('text', '')}\n")
+    return "\n---\n".join(formatted)
+
+
+def _format_fact_results(data: dict) -> str:
+    results = data.get("results", [])
+    if not results:
+        return "No matching facts found."
+    formatted = []
+    for r in results:
+        perm = "permanent" if r.get("is_permanent") else "decaying"
+        formatted.append(
+            f"[{r.get('category', '?')}|{perm}|score:{r.get('score', 0):.3f}] "
+            f"{r.get('text', '')}"
+        )
+    return "\n".join(formatted)
+
+
+def _format_stats(data: dict) -> str:
+    import json
+    return json.dumps(data, indent=2)
+
+
+async def main():
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s | %(name)s | %(levelname)s | %(message)s",
+        stream=sys.stderr,
+    )
+
+    # Resolve API key on startup (triggers auto-provision if needed)
+    api_key = _get_api_key()
+    if not api_key:
+        logger.warning("No API key resolved — tools will prompt for signup")
+
+    logger.info(f"ctxstore MCP server starting (endpoint: {BASE_URL})")
+
+    async with stdio_server() as (read_stream, write_stream):
+        await app.run(
+            read_stream,
+            write_stream,
+            app.create_initialization_options(),
+        )

ctxstore_mcp-1.0.0/ctxstore_mcp/setup_cli.py

@@ -0,0 +1,156 @@
+"""
+ctxstore-setup — one-command MCP client configuration.
+
+Detects installed AI clients, injects ctxstore MCP config, provisions tenant.
+Usage: ctxstore-setup
+"""
+
+import json
+import os
+import shutil
+import sys
+from pathlib import Path
+from typing import Optional
+
+from .auth import get_or_provision
+
+CTXSTORE_URL = os.getenv("CTXSTORE_URL", "https://ctxstore.ai").rstrip("/")
+
+# ── MCP client config locations ────────────────────────────────────────────────
+
+MCP_CLIENTS = [
+    {
+        "name": "Claude Desktop",
+        "paths": [
+            Path.home() / "Library" / "Application Support" / "Claude" / "claude_desktop_config.json",
+            Path.home() / ".config" / "claude" / "claude_desktop_config.json",
+        ],
+        "wrapper": "mcpServers",
+    },
+    {
+        "name": "Claude Code",
+        "paths": [Path.home() / ".claude.json"],
+        "wrapper": "mcpServers",
+    },
+    {
+        "name": "Cursor",
+        "paths": [Path.home() / ".cursor" / "mcp.json"],
+        "wrapper": "mcpServers",
+    },
+    {
+        "name": "VS Code",
+        "paths": [Path.home() / ".vscode" / "mcp.json"],
+        "wrapper": "servers",
+    },
+    {
+        "name": "Windsurf",
+        "paths": [Path.home() / ".windsurf" / "mcp.json"],
+        "wrapper": "mcpServers",
+    },
+]
+
+
+def _inject_config(config_path: Path, wrapper: str, api_key: str) -> bool:
+    """
+    Non-destructively inject ctxstore entry into an MCP client config.
+    Backs up the original file before modifying.
+    Returns True on success.
+    """
+    try:
+        with open(config_path) as f:
+            try:
+                config = json.load(f)
+            except json.JSONDecodeError:
+                config = {}
+
+        if wrapper not in config:
+            config[wrapper] = {}
+
+        config[wrapper]["ctxstore"] = {
+            "command": "ctxstore-mcp",
+            "env": {"TENANT_API_KEY": api_key},
+        }
+
+        # Backup
+        shutil.copy2(config_path, str(config_path) + ".bak")
+
+        with open(config_path, "w") as f:
+            json.dump(config, f, indent=2)
+            f.write("\n")
+
+        return True
+    except (OSError, json.JSONDecodeError) as e:
+        print(f"  ✗ Error modifying {config_path}: {e}", file=sys.stderr)
+        return False
+
+
+def _health_check() -> bool:
+    """Check if ctxstore.ai is reachable."""
+    try:
+        import httpx
+        resp = httpx.get(f"{CTXSTORE_URL}/api/health", timeout=10.0)
+        return resp.status_code == 200 and "ok" in resp.text.lower()
+    except Exception:
+        return False
+
+
+def main() -> None:
+    print("\n✦ ctxstore-setup\n")
+
+    # Step 1: Get/provision API key
+    print("→ Checking credentials...")
+    try:
+        api_key = get_or_provision()
+        print(f"  ✓ API key ready")
+    except RuntimeError as e:
+        print(f"  ✗ {e}", file=sys.stderr)
+        sys.exit(1)
+
+    # Step 2: Detect and configure MCP clients
+    print("\n→ Detecting MCP clients...")
+    configured = []
+    found_any = False
+
+    for client in MCP_CLIENTS:
+        for config_path in client["paths"]:
+            if config_path.exists():
+                found_any = True
+                print(f"  Found: {client['name']} ({config_path})")
+                success = _inject_config(config_path, client["wrapper"], api_key)
+                if success:
+                    configured.append(client["name"])
+                    print(f"  ✓ Configured {client['name']}")
+                break  # Only configure first found path per client
+
+    if not found_any:
+        print("  No MCP clients detected.")
+        print("\n  Add this to your client's MCP config manually:")
+        print("""
+  {
+    "mcpServers": {
+      "ctxstore": {
+        "command": "ctxstore-mcp",
+        "env": { "TENANT_API_KEY": \"""" + api_key + """\" }
+      }
+    }
+  }""")
+
+    # Step 3: Health check
+    print("\n→ Health check...")
+    if _health_check():
+        print("  ✓ ctxstore.ai is reachable")
+    else:
+        print("  ⚠ Could not reach ctxstore.ai — check your connection")
+
+    # Step 4: Summary
+    print("\n" + "━" * 50)
+    print("✓ ctxstore-setup complete!\n")
+    if configured:
+        print(f"  Configured: {', '.join(configured)}")
+        print("  → Restart your AI client to activate memory")
+    print(f"\n  Docs: {CTXSTORE_URL}/docs")
+    print("━" * 50 + "\n")
+
+
+if __name__ == "__main__":
+    main()

ctxstore_mcp-1.0.0/ctxstore_mcp.egg-info/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: ctxstore-mcp
+Version: 1.0.0
+Summary: Persistent AI memory via MCP. Give your AI agent long-term memory in 30 seconds.
+Author-email: "ctxstore.ai" <hello@ctxstore.ai>
+License-Expression: MIT
+Project-URL: Homepage, https://ctxstore.ai
+Project-URL: Documentation, https://ctxstore.ai/docs
+Project-URL: Repository, https://github.com/ctxstore-ai/ctxstore-mcp
+Project-URL: Bug Tracker, https://github.com/ctxstore-ai/ctxstore-mcp/issues
+Keywords: mcp,ai,memory,context,vector,llm,claude,cursor
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: httpx>=0.25.0
+Dynamic: license-file
+
+# ctxstore-mcp

ctxstore_mcp-1.0.0/ctxstore_mcp.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+ctxstore_mcp/__init__.py
+ctxstore_mcp/__main__.py
+ctxstore_mcp/auth.py
+ctxstore_mcp/server.py
+ctxstore_mcp/setup_cli.py
+ctxstore_mcp.egg-info/PKG-INFO
+ctxstore_mcp.egg-info/SOURCES.txt
+ctxstore_mcp.egg-info/dependency_links.txt
+ctxstore_mcp.egg-info/entry_points.txt
+ctxstore_mcp.egg-info/requires.txt
+ctxstore_mcp.egg-info/top_level.txt

ctxstore_mcp-1.0.0/ctxstore_mcp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ctxstore_mcp-1.0.0/ctxstore_mcp.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+ctxstore-mcp = ctxstore_mcp:main
+ctxstore-setup = ctxstore_mcp.setup_cli:main

ctxstore_mcp-1.0.0/ctxstore_mcp.egg-info/requires.txt

@@ -0,0 +1,2 @@
+mcp>=1.0.0
+httpx>=0.25.0

ctxstore_mcp-1.0.0/ctxstore_mcp.egg-info/top_level.txt

@@ -0,0 +1 @@
+ctxstore_mcp

ctxstore_mcp-1.0.0/pyproject.toml

@@ -0,0 +1,39 @@
+[project]
+name = "ctxstore-mcp"
+version = "1.0.0"
+description = "Persistent AI memory via MCP. Give your AI agent long-term memory in 30 seconds."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    {name = "ctxstore.ai", email = "hello@ctxstore.ai"},
+]
+keywords = ["mcp", "ai", "memory", "context", "vector", "llm", "claude", "cursor"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "mcp>=1.0.0",
+    "httpx>=0.25.0",
+]
+
+[project.scripts]
+ctxstore-mcp = "ctxstore_mcp:main"
+ctxstore-setup = "ctxstore_mcp.setup_cli:main"
+
+[project.urls]
+Homepage = "https://ctxstore.ai"
+Documentation = "https://ctxstore.ai/docs"
+Repository = "https://github.com/ctxstore-ai/ctxstore-mcp"
+"Bug Tracker" = "https://github.com/ctxstore-ai/ctxstore-mcp/issues"
+
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"

ctxstore_mcp-1.0.0/setup.cfg

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