naragate-mcp 0.3.0__py3-none-any.whl

naragate_mcp/__init__.py

@@ -0,0 +1,6 @@
+"""Naragate MCP server package."""
+
+from naragate_mcp.client import NaragateClient, NaragateError
+
+__all__ = ["NaragateClient", "NaragateError"]
+__version__ = "0.3.0"

naragate_mcp/client.py

@@ -0,0 +1,134 @@
+"""Thin REST client for the Naragate backend.
+
+Every non-web surface (MCP tools, scripts) goes through the backend so that
+evidence caching and credit accounting live in exactly one place. Configure the
+backend with `NARAGATE_BACKEND_URL` (default `http://127.0.0.1:5678`).
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+import httpx
+
+DEFAULT_BASE_URL = "http://127.0.0.1:5678"
+
+
+class NaragateError(RuntimeError):
+    """Raised when the Naragate backend is unreachable or returns an error."""
+
+    def __init__(self, message: str, status: int | None = None, detail: Any = None):
+        super().__init__(message)
+        self.status = status
+        self.detail = detail
+
+
+class NaragateClient:
+    def __init__(self, base_url: str | None = None, timeout: float = 600.0, transport: httpx.BaseTransport | None = None):
+        self.base_url = (
+            base_url or os.environ.get("NARAGATE_BACKEND_URL") or DEFAULT_BASE_URL
+        ).rstrip("/")
+        self.timeout = timeout
+        self._transport = transport
+
+    def _request(self, method: str, path: str, **kwargs: Any) -> Any:
+        url = f"{self.base_url}{path}"
+        try:
+            with httpx.Client(timeout=self.timeout, transport=self._transport) as client:
+                resp = client.request(method, url, **kwargs)
+        except httpx.HTTPError as exc:  # network / timeout
+            raise NaragateError(
+                f"cannot reach Naragate backend at {self.base_url}: {exc}"
+            ) from exc
+
+        if resp.status_code >= 400:
+            detail: Any
+            try:
+                detail = resp.json().get("detail")
+            except Exception:  # noqa: BLE001 — non-JSON error body
+                detail = resp.text
+            raise NaragateError(
+                f"{method} {path} -> HTTP {resp.status_code}: {detail}",
+                status=resp.status_code,
+                detail=detail,
+            )
+        return resp.json()
+
+    # ---- high-level, credit-safe operations (all reuse the backend pipeline) ----
+
+    def analyze(self, narrative: str) -> dict[str, Any]:
+        return self._request("POST", "/api/v1/analyze", json={"narrative": narrative})
+
+    def get_claim(self, claim_id: str) -> dict[str, Any]:
+        return self._request("GET", f"/api/v1/claims/{claim_id}")
+
+    def list_history(self, limit: int = 20) -> list[dict[str, Any]]:
+        return self._request("GET", "/api/v1/claims/", params={"limit": limit})
+
+    def get_summary(self) -> dict[str, Any]:
+        return self._request("GET", "/api/v1/claims/summary")
+
+    def get_precheck(self, sector: str | None = None) -> dict[str, Any]:
+        params = {"sector": sector} if sector else None
+        return self._request("GET", "/api/v1/precheck/", params=params)
+
+    def list_templates(self) -> dict[str, Any]:
+        return self._request("GET", "/api/v1/templates")
+
+    def get_usage(self) -> dict[str, Any]:
+        return self._request("GET", "/api/v1/usage")
+
+    # ---- low-level agent tools (parity with skills/*/tools.yaml) ----
+
+    def sectors_company_report(self, ticker: str, sections: list[str] | None = None) -> dict[str, Any]:
+        params = {"ticker": ticker, "sections": ",".join(sections)} if sections else {"ticker": ticker}
+        return self._request("GET", "/api/v1/tools/sectors/company-report", params=params)
+
+    def sectors_subsector_report(self, sub_sector: str, sections: list[str] | None = None) -> dict[str, Any]:
+        params = {"sub_sector": sub_sector}
+        if sections:
+            params["sections"] = ",".join(sections)
+        return self._request("GET", "/api/v1/tools/sectors/subsector-report", params=params)
+
+    def sectors_quarterly_financials(self, ticker: str, n_quarters: int = 8) -> list[dict[str, Any]]:
+        return self._request("GET", "/api/v1/tools/sectors/quarterly-financials",
+                             params={"ticker": ticker, "n_quarters": n_quarters})
+
+    def sectors_daily_transaction(self, ticker: str, start: str | None = None, end: str | None = None) -> list[dict[str, Any]]:
+        params: dict[str, Any] = {"ticker": ticker}
+        if start:
+            params["start"] = start
+        if end:
+            params["end"] = end
+        return self._request("GET", "/api/v1/tools/sectors/daily-transaction", params=params)
+
+    def sectors_news(self, ticker: str, limit: int = 20) -> dict[str, Any]:
+        return self._request("GET", "/api/v1/tools/sectors/news", params={"ticker": ticker, "limit": limit})
+
+    def sectors_corporate_actions(self, ticker: str) -> dict[str, Any]:
+        return self._request("GET", "/api/v1/tools/sectors/corporate-actions", params={"ticker": ticker})
+
+    def sectors_filings(self, ticker: str, filing_type: str | None = None) -> dict[str, Any]:
+        params: dict[str, Any] = {"ticker": ticker}
+        if filing_type:
+            params["filing_type"] = filing_type
+        return self._request("GET", "/api/v1/tools/sectors/filings", params=params)
+
+    def evidence_cache_get(self, ticker: str) -> dict[str, Any]:
+        return self._request("GET", "/api/v1/tools/evidence-cache", params={"ticker": ticker})
+
+    def evidence_cache_merge(self, ticker: str, key: str, value: Any, ttl: int | None = None) -> dict[str, Any]:
+        body: dict[str, Any] = {"ticker": ticker, "key": key, "value": value}
+        if ttl:
+            body["ttl"] = ttl
+        return self._request("POST", "/api/v1/tools/evidence-cache", json=body)
+
+    def llm_complete(self, prompt: str, system: str | None = None,
+                     response_format: dict | None = None, role: str = "default") -> dict[str, Any]:
+        body: dict[str, Any] = {"prompt": prompt, "role": role}
+        if system:
+            body["system"] = system
+        if response_format:
+            body["response_format"] = response_format
+        return self._request("POST", "/api/v1/tools/llm-complete", json=body)

naragate_mcp/server.py

@@ -0,0 +1,269 @@
+"""Naragate MCP server.
+
+Exposes the Naragate reality-gap engine over the Model Context Protocol so the
+same skills package works on any MCP-capable harness (Claude Code, Claude
+Desktop, Cursor, Windsurf, Zed, VS Code, opencode, Codex, ...).
+
+Design: this server is a thin, credit-safe client over the Naragate backend's
+REST API. It never talks to Sectors directly — all evidence gathering, caching
+and credit accounting happen in the backend pipeline, so a non-web run costs
+exactly the same as a web-UI run (0 additional Sectors calls on a warm cache).
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from typing import Any
+
+from mcp.server.fastmcp import FastMCP
+
+from naragate_mcp.client import NaragateClient, NaragateError
+
+mcp = FastMCP("naragate")
+
+_EVIDENCE_KEYS = ("valuation", "fundamental", "market", "news", "corporate_actions", "filings")
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _compact(state: dict[str, Any]) -> dict[str, Any]:
+    """Shape a finished claim into a compact, agent-friendly report."""
+    claim = state.get("claim") or {}
+    score = state.get("score") or {}
+    skeptic = state.get("skeptic") or {}
+    evidence = state.get("evidence") or {}
+    policy = evidence.get("policy") or {}
+
+    return {
+        "claim_id": state.get("claim_id"),
+        "narrative": state.get("narrative"),
+        "status": state.get("status"),
+        "clarification": state.get("clarification"),
+        "ticker": claim.get("ticker"),
+        "category": claim.get("category"),
+        "direction": claim.get("direction"),
+        "assertion": claim.get("assertion"),
+        "is_policy": claim.get("is_policy"),
+        "sector": claim.get("sector"),
+        "sector_members": claim.get("sector_members"),
+        "reality_gap_score": score.get("reality_gap_score"),
+        "verdict": score.get("verdict"),
+        "explanation": score.get("explanation"),
+        "dimensions": score.get("dimensions"),
+        "evidence_sections": [k for k in _EVIDENCE_KEYS if evidence.get(k)],
+        "policy_events": (policy.get("policy_events") or []) if claim.get("is_policy") else [],
+        "skeptic": {
+            "score": skeptic.get("skepticism_score"),
+            "counter_arguments": len(skeptic.get("counter_arguments") or []),
+            "ambiguity_points": len(skeptic.get("ambiguity_points") or []),
+            "missing_evidence": len(skeptic.get("missing_evidence") or []),
+        },
+        "url": f"https://naragate.ilkomers.com/results/{state.get('claim_id')}",
+    }
+
+
+# --------------------------------------------------------------------- tools --
+
+@mcp.tool()
+def analyze_narrative(narrative: str) -> dict[str, Any]:
+    """Verify an Indonesian market narrative end-to-end and return the Reality Gap report.
+
+    Runs the full Naragate pipeline (claim parsing, evidence, skeptic, judge,
+    score) against real Sectors v2 data. Returns the score (0-100), verdict,
+    direction, evidence sections, policy signal and skeptic summary.
+
+    Args:
+        narrative: the Indonesian market claim to verify, e.g.
+            "PE BBCA mahal di 25x, jauh di atas rata-rata sektor 18x."
+    """
+    state = NaragateClient().analyze(narrative)
+    if state.get("status") == "needs_clarification":
+        return {
+            "claim_id": state.get("claim_id"),
+            "narrative": state.get("narrative"),
+            "status": "needs_clarification",
+            "clarification": state.get("message"),
+            "hint": "Name a specific 4-letter IDX ticker so the claim can be verified.",
+        }
+    return _compact(state)
+
+
+@mcp.tool()
+def analyze_template(template_id: str) -> dict[str, Any]:
+    """Verify one of the 12 curated demo templates by id (same tiles as the web dashboard).
+
+    Use `list_templates` to discover ids. Example ids: `valuation`, `market`,
+    `policy_bbm`, `policy_hba`, `policy_nickel`, `contradiction`, `no_ticker`.
+    """
+    templates = NaragateClient().list_templates().get("templates", [])
+    match = next((t for t in templates if t.get("id") == template_id), None)
+    if match is None:
+        return {"error": f"unknown template_id '{template_id}'", "available": [t["id"] for t in templates]}
+    return analyze_narrative(match["narrative"])
+
+
+@mcp.tool()
+def list_templates() -> dict[str, Any]:
+    """List the 12 curated demo narratives (the dashboard tiles) so non-web users get the same entry points."""
+    return NaragateClient().list_templates()
+
+
+@mcp.tool()
+def get_claim(claim_id: str) -> dict[str, Any]:
+    """Fetch the full stored record for a claim (claim, evidence, skeptic, score, policy)."""
+    return NaragateClient().get_claim(claim_id)
+
+
+@mcp.tool()
+def get_reality_gap(claim_id: str) -> dict[str, Any]:
+    """Fetch a compact Reality Gap report for a stored claim by id."""
+    return _compact(NaragateClient().get_claim(claim_id))
+
+
+@mcp.tool()
+def list_history(limit: int = 20) -> dict[str, Any]:
+    """List recent analyses, most recent first (the web UI's History page)."""
+    claims = NaragateClient().list_history(limit=limit)
+    rows = [
+        {
+            "claim_id": c.get("claim_id"),
+            "narrative": c.get("narrative"),
+            "status": c.get("status"),
+            "ticker": (c.get("claim") or {}).get("ticker"),
+            "created_at": c.get("created_at"),
+            "reality_gap_score": (c.get("score") or {}).get("reality_gap_score"),
+            "verdict": (c.get("score") or {}).get("verdict"),
+        }
+        for c in claims
+    ]
+    return {"count": len(rows), "claims": rows}
+
+
+@mcp.tool()
+def get_trend_summary() -> dict[str, Any]:
+    """Aggregate trends across completed analyses: totals, average score, verdict distribution, per-ticker history."""
+    return NaragateClient().get_summary()
+
+
+@mcp.tool()
+def get_policy_precheck(sector: str | None = None) -> dict[str, Any]:
+    """Policy-to-price pre-check (T1). Scoped to the claim's sector to avoid cross-sector leakage.
+
+    Args:
+        sector: optional sector slug, e.g. `oil-gas`, `coal`, `nickel`.
+    """
+    return NaragateClient().get_precheck(sector=sector)
+
+
+@mcp.tool()
+def get_usage() -> dict[str, Any]:
+    """Sectors API and LLM credit usage: totals, cache hits, remaining budget, daily breakdown."""
+    return NaragateClient().get_usage()
+
+
+# ---------------------------------------------- low-level tools (tools.yaml parity) --
+# These mirror skills/*/tools.yaml exactly, for harnesses that want to compose
+# per-agent. Credit discipline: check `evidence_cache_get` first, then call the
+# `sectors_*` tool on a miss and `evidence_cache_merge` the result.
+
+
+@mcp.tool()
+def sectors_company_report(ticker: str, sections: list[str] | None = None) -> dict[str, Any]:
+    """Sectors v2 company report (sections: valuation, overview, financials)."""
+    return NaragateClient().sectors_company_report(ticker, sections)
+
+
+@mcp.tool()
+def sectors_subsector_report(sub_sector: str, sections: list[str] | None = None) -> dict[str, Any]:
+    """Sectors v2 subsector report (sections: statistics, valuation, ...)."""
+    return NaragateClient().sectors_subsector_report(sub_sector, sections)
+
+
+@mcp.tool()
+def sectors_quarterly_financials(ticker: str, n_quarters: int = 8) -> list[dict[str, Any]]:
+    """Sectors v2 quarterly financials (revenue, earnings, margins) for a ticker."""
+    return NaragateClient().sectors_quarterly_financials(ticker, n_quarters)
+
+
+@mcp.tool()
+def sectors_daily_transaction(ticker: str, start: str | None = None, end: str | None = None) -> list[dict[str, Any]]:
+    """Sectors v2 daily transaction data (price, volume, close). Sectors caps a call at 90 days."""
+    return NaragateClient().sectors_daily_transaction(ticker, start, end)
+
+
+@mcp.tool()
+def sectors_news(ticker: str, limit: int = 20) -> dict[str, Any]:
+    """Sectors v2 recent news headlines for a ticker."""
+    return NaragateClient().sectors_news(ticker, limit)
+
+
+@mcp.tool()
+def sectors_corporate_actions(ticker: str) -> dict[str, Any]:
+    """Sectors v2 corporate actions (dividends, splits, warrants) for a ticker."""
+    return NaragateClient().sectors_corporate_actions(ticker)
+
+
+@mcp.tool()
+def sectors_filings(ticker: str, filing_type: str | None = None) -> dict[str, Any]:
+    """Sectors v2 insider-trade filings for a ticker (filing_type: buy, sell, others)."""
+    return NaragateClient().sectors_filings(ticker, filing_type)
+
+
+@mcp.tool()
+def evidence_cache_get(ticker: str) -> dict[str, Any]:
+    """Read the full Evidence Graph for a ticker from the cache (null on miss)."""
+    return NaragateClient().evidence_cache_get(ticker)
+
+
+@mcp.tool()
+def evidence_cache_merge(ticker: str, key: str, value: Any, ttl: int | None = None) -> dict[str, Any]:
+    """Atomically merge one section into the cached Evidence Graph for a ticker."""
+    return NaragateClient().evidence_cache_merge(ticker, key, value, ttl)
+
+
+@mcp.tool()
+def llm_complete(prompt: str, system: str | None = None,
+                 response_format: dict | None = None, role: str = "default") -> dict[str, Any]:
+    """Run a one-shot completion on Naragate's configured LLM and return the raw text."""
+    return NaragateClient().llm_complete(prompt, system, response_format, role)
+
+
+# ----------------------------------------------------------------- resources --
+
+@mcp.resource("naragate://templates")
+def templates_resource() -> str:
+    """The 12 curated demo templates as JSON."""
+    return json.dumps(NaragateClient().list_templates(), ensure_ascii=False, indent=2)
+
+
+@mcp.resource("naragate://usage")
+def usage_resource() -> str:
+    """Current Sectors/LLM credit usage as JSON."""
+    return json.dumps(NaragateClient().get_usage(), ensure_ascii=False, indent=2)
+
+
+@mcp.resource("naragate://history")
+def history_resource() -> str:
+    """Recent analyses as JSON."""
+    return json.dumps(NaragateClient().list_history(limit=20), ensure_ascii=False, indent=2)
+
+
+@mcp.resource("naragate://claim/{claim_id}")
+def claim_resource(claim_id: str) -> str:
+    """A stored claim's compact Reality Gap report as JSON."""
+    try:
+        return json.dumps(_compact(NaragateClient().get_claim(claim_id)), ensure_ascii=False, indent=2)
+    except NaragateError as exc:
+        return json.dumps({"error": str(exc)}, ensure_ascii=False)
+
+
+def main() -> None:
+    """Entry point for the `naragate-mcp` console script (stdio transport)."""
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

naragate_mcp-0.3.0.dist-info/METADATA

@@ -0,0 +1,228 @@
+Metadata-Version: 2.4
+Name: naragate-mcp
+Version: 0.3.0
+Summary: MCP server exposing the Naragate reality-gap evidence engine to any MCP-capable agent (desktop, CLI, IDE).
+Author-email: Devid HW <devid.wahid@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/masdevid/naragate
+Project-URL: Repository, https://github.com/masdevid/naragate
+Project-URL: Issues, https://github.com/masdevid/naragate/issues
+Project-URL: Changelog, https://github.com/masdevid/naragate/releases
+Project-URL: Documentation, https://github.com/masdevid/naragate/blob/master/mcp/README.md
+Keywords: mcp,model-context-protocol,ai-agents,claude,cursor,opencode,codex,stock,indonesia,idx,sectors,fact-check
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Operating System :: OS Independent
+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 :: Office/Business :: Financial :: Investment
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp<2,>=1.2
+Requires-Dist: httpx>=0.27
+Provides-Extra: test
+Requires-Dist: pytest>=8.0.0; extra == "test"
+Requires-Dist: pytest-asyncio>=0.23.0; extra == "test"
+Dynamic: license-file
+
+# Naragate MCP Server
+
+One portable tool layer so the **same Naragate experience** works on the custom web UI *and* on any
+MCP-capable agent surface — Claude Code, Claude Desktop, Cursor, Windsurf, Zed, VS Code, opencode,
+Codex, or your own harness.
+
+```
+                 ┌─ custom web UI (Angular)
+Naragate backend ├─ MCP server  ──► any MCP harness (desktop / CLI / IDE)
+(FastAPI+cache)  └─ Pi agent harness
+```
+
+## The three layers (what a user actually needs)
+
+| Layer | Path | Required? | Role |
+|---|---|---|---|
+| **MCP server** | `mcp/` (this package) | **Yes** for non-web | The tools: analyze, history, trend, precheck, usage |
+| **Skills** | `skills/` | **Yes** | Domain instructions: how to parse, challenge and score a claim |
+| **Agents** | `agents/` | No | Optional orchestration for harnesses with subagents |
+
+Skills alone can't fetch data (they declare tools but don't ship them); agents+skills add
+orchestration but still have no data. **The MCP bundle is the data layer** — with it, skills run
+anywhere.
+
+## Credit safety (hard requirement)
+
+This server **never talks to Sectors directly**. Every tool is a thin client over the Naragate
+backend, so evidence gathering, the Evidence Graph cache and credit accounting live in exactly one
+place. A warm re-run costs **0 additional Sectors calls**, identical to the web UI. There is a test
+asserting the MCP package never references the Sectors API.
+
+## Install
+
+```bash
+uvx naragate-mcp           # run without installing (recommended)
+pip install naragate-mcp   # or install into your environment
+pipx install naragate-mcp
+```
+
+From a checkout: `pip install -e mcp`.
+
+Point it at your backend (default `http://127.0.0.1:5678`):
+
+```bash
+export NARAGATE_BACKEND_URL="http://127.0.0.1:5678"
+naragate-mcp
+```
+
+Transport is **stdio**.
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `analyze_narrative(narrative)` | Verify a narrative end-to-end → Reality Gap score, verdict, evidence sections, policy signal, skeptic summary |
+| `analyze_template(template_id)` | Run one of the 12 curated dashboard templates by id |
+| `list_templates()` | The 12 curated narratives (same tiles as the web dashboard) |
+| `get_claim(claim_id)` | Full stored record (claim, evidence, skeptic, score, policy) |
+| `get_reality_gap(claim_id)` | Compact report for a stored claim |
+| `list_history(limit)` | Recent analyses, most recent first |
+| `get_trend_summary()` | Totals, average score, verdict distribution, per-ticker history |
+| `get_policy_precheck(sector)` | Policy→price pre-check, scoped to the claim's sector |
+| `get_usage()` | Sectors/LLM credit usage, cache hits, remaining budget |
+
+### Low-level tools — full `tools.yaml` parity
+
+Every primitive declared in `skills/*/tools.yaml` is also exposed, for harnesses that want to compose
+per-agent exactly like the Pi pipeline (check the cache, then fetch on a miss and merge back):
+
+| Tool | What it does |
+|---|---|
+| `sectors_company_report(ticker, sections)` | Sectors v2 company report (valuation/overview/financials) |
+| `sectors_subsector_report(sub_sector, sections)` | Sectors v2 subsector report |
+| `sectors_quarterly_financials(ticker, n_quarters)` | Sectors v2 quarterly financials |
+| `sectors_daily_transaction(ticker, start, end)` | Sectors v2 daily price/volume (Sectors caps a call at 90 days) |
+| `sectors_news(ticker, limit)` | Sectors v2 news headlines |
+| `sectors_corporate_actions(ticker)` | Sectors v2 corporate actions |
+| `sectors_filings(ticker, filing_type)` | Sectors v2 insider-trade filings |
+| `evidence_cache_get(ticker)` | Read the Evidence Graph (null on miss) |
+| `evidence_cache_merge(ticker, key, value, ttl?)` | Merge one section into the cache |
+| `llm_complete(prompt, system?, response_format?, role?)` | One-shot completion on Naragate's configured LLM |
+
+A test (`tests/test_parity.py`) asserts that **every** tool declared in any `skills/*/tools.yaml`
+exists on the server, so this can't drift.
+
+## Resources
+
+- `naragate://templates`
+- `naragate://usage`
+- `naragate://history`
+- `naragate://claim/{claim_id}`
+
+## Harness configuration
+
+### Claude Code
+
+```bash
+claude mcp add naragate -e NARAGATE_BACKEND_URL=http://127.0.0.1:5678 -- uvx naragate-mcp
+```
+
+### Claude Desktop (`claude_desktop_config.json`)
+
+```json
+{
+  "mcpServers": {
+    "naragate": {
+      "command": "uvx",
+      "args": ["naragate-mcp"],
+      "env": { "NARAGATE_BACKEND_URL": "http://127.0.0.1:5678" }
+    }
+  }
+}
+```
+
+### opencode (`opencode.json`)
+
+```json
+{
+  "mcp": {
+    "naragate": {
+      "type": "local",
+      "command": ["uvx", "naragate-mcp"],
+      "enabled": true,
+      "environment": { "NARAGATE_BACKEND_URL": "http://127.0.0.1:5678" }
+    }
+  }
+}
+```
+
+### Cursor (`.cursor/mcp.json`) / Windsurf / Zed / VS Code
+
+```json
+{
+  "mcpServers": {
+    "naragate": {
+      "command": "uvx",
+      "args": ["naragate-mcp"],
+      "env": { "NARAGATE_BACKEND_URL": "http://127.0.0.1:5678" }
+    }
+  }
+}
+```
+
+### Codex (`~/.codex/config.toml`)
+
+```toml
+[mcp_servers.naragate]
+command = "uvx"
+args = ["naragate-mcp"]
+env = { NARAGATE_BACKEND_URL = "http://127.0.0.1:5678" }
+```
+
+## Example prompts
+
+- *"Use naragate to verify: PE BBCA mahal di 25x."*
+- *"List the naragate templates and run the nickel policy one."*
+- *"Show my last 10 naragate analyses and the trend summary."*
+- *"What's my Sectors credit usage?"*
+
+## Tests
+
+```bash
+cd mcp
+python -m pytest -q
+```
+
+Covers the REST client (mock transport), the tool surface, compact-report shaping, and the
+credit-safety guarantee. No live backend or Sectors access required.
+
+## Publishing
+
+Releases publish automatically via [`.github/workflows/publish-mcp.yml`](https://github.com/masdevid/naragate/blob/master/.github/workflows/publish-mcp.yml)
+when a GitHub release is published (using the `PYPI_TOKEN` repository secret), or locally:
+
+```bash
+mcp/publish.sh              # PyPI
+mcp/publish.sh testpypi     # TestPyPI
+```
+
+`publish.sh` reads `PYPI_TOKEN` from the environment or the repo-root `.env`, builds with
+`python -m build`, validates with `twine check`, and uploads — the token is never echoed. Manual
+equivalent:
+
+```bash
+python -m build
+python -m twine check dist/*
+TWINE_USERNAME=__token__ TWINE_PASSWORD="$PYPI_TOKEN" python -m twine upload dist/*
+```
+
+## Related
+
+- [Naragate README](https://github.com/masdevid/naragate#readme) — project overview and the "Use Naragate from any MCP agent" section
+- [Skills](https://github.com/masdevid/naragate/blob/master/skills/README.md) — the 13 skills whose `tools.yaml` this server satisfies
+- [Agents](https://github.com/masdevid/naragate/blob/master/agents/README.md) — optional subagent topology for harnesses that support it
+- [Parity test](https://github.com/masdevid/naragate/blob/master/mcp/tests/test_parity.py) — enforces that every `skills/*/tools.yaml` tool is exposed here

naragate_mcp-0.3.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+naragate_mcp/__init__.py,sha256=cLukElhuV1w-zwMhXbEtYYENGW8nrNgdHANppDj1_hE,167
+naragate_mcp/client.py,sha256=g5a6pV5UaD7UHNauvCxYi1mGE5VUP5Y7diHaRceGc4E,5913
+naragate_mcp/server.py,sha256=4QmJKZGFTdgfyFZtr9VS8_luruf7sjMsG7EDREUZPvc,10443
+naragate_mcp-0.3.0.dist-info/licenses/LICENSE,sha256=cEZ6Etdzgq1eRitg54aCE-FQXJrw-Q4jVAL8EaeJLB4,1065
+naragate_mcp-0.3.0.dist-info/METADATA,sha256=j2OVJwENzTbARqn9vpUoevd-y9fh8tE7UnWP8xx-X7s,8439
+naragate_mcp-0.3.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+naragate_mcp-0.3.0.dist-info/entry_points.txt,sha256=sB8xSAwZvFr6PgtPfza2PXlRfM_bRR7HcRJTZArMiaA,58
+naragate_mcp-0.3.0.dist-info/top_level.txt,sha256=NInI4wfT2Xlohju5d-NFyABlJvxPX0edYg6Jpjh892o,13
+naragate_mcp-0.3.0.dist-info/RECORD,,

naragate_mcp-0.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

naragate_mcp-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+naragate-mcp = naragate_mcp.server:main

naragate_mcp-0.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Devid HW
+
+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.

naragate_mcp-0.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+naragate_mcp