kglite-docs 0.0.1__tar.gz

kglite_docs-0.0.1/.gitignore

@@ -0,0 +1,42 @@
+# Python
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info/
+.eggs/
+
+# Virtual environments
+.venv/
+venv/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+
+# Testing / coverage
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+htmlcov/
+.coverage
+coverage.xml
+
+
+# Local artifacts
+*.kgl
+!sample_data/*.kgl
+tmp/
+.DS_Store
+
+# Built docs
+site/
+
+# Sample PDFs (downloadable via scripts/fetch_sample_pdfs.sh — too big for the repo)
+sample_data/pdfs/
+sample_data/subset/
+demo.kgl
+synthesis_*.md
+factcheck_*.json

kglite_docs-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kristian dF Kollsgård
+
+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.

kglite_docs-0.0.1/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: kglite-docs
+Version: 0.0.1
+Summary: Agent-first PDF knowledge base — chunk, embed, cluster, enrich, and serve over MCP. Built on kglite + bge-m3.
+Project-URL: Homepage, https://github.com/kkollsga/kglite-docs
+Project-URL: Repository, https://github.com/kkollsga/kglite-docs
+Project-URL: Issues, https://github.com/kkollsga/kglite-docs/issues
+Author-email: Kristian dF Kollsgård <kkollsg@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: bge-m3,embeddings,kglite,knowledge-graph,mcp,pdf,rag
+Classifier: Development Status :: 3 - Alpha
+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 :: Information Analysis
+Classifier: Topic :: Text Processing :: Indexing
+Requires-Python: >=3.10
+Requires-Dist: huggingface-hub>=0.26
+Requires-Dist: kglite>=0.10.4
+Requires-Dist: markdownify>=0.13
+Requires-Dist: numpy>=1.26
+Requires-Dist: onnxruntime>=1.18
+Requires-Dist: pandas>=2.0
+Requires-Dist: pymupdf4llm>=0.0.17
+Requires-Dist: pymupdf>=1.24
+Requires-Dist: python-docx>=1.0
+Requires-Dist: python-pptx>=0.6
+Requires-Dist: reportlab>=4.0
+Requires-Dist: tokenizers>=0.20
+Provides-Extra: dev
+Requires-Dist: mypy>=1.13; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.7; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs-material>=9.5; extra == 'docs'
+Requires-Dist: mkdocs>=1.6; extra == 'docs'
+Requires-Dist: mkdocstrings[python]>=0.27; extra == 'docs'
+Provides-Extra: mcp
+Requires-Dist: mcp-methods>=0.3; extra == 'mcp'
+Requires-Dist: mcp>=1.0; extra == 'mcp'
+Description-Content-Type: text/markdown
+
+# kglite-docs
+
+> **Agent-first knowledge base for documents.** Ingest PDFs, Office files, Markdown, HTML, or images; chunk + embed them with [BAAI/bge-m3](https://huggingface.co/BAAI/bge-m3); cluster, tag, summarise, fact-check, translate, and review them — and serve the whole thing to AI agents over MCP.
+
+[![PyPI](https://img.shields.io/pypi/v/kglite-docs.svg)](https://pypi.org/project/kglite-docs/)
+[![Python](https://img.shields.io/pypi/pyversions/kglite-docs.svg)](https://pypi.org/project/kglite-docs/)
+[![Docs](https://readthedocs.org/projects/kglite-docs/badge/?version=latest)](https://kglite-docs.readthedocs.io/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Built on [`kglite`](https://github.com/kkollsga/kglite) (storage + vector search + clustering) and [`mcp-methods`](https://github.com/kkollsga/mcp-methods) (MCP framework).
+
+---
+
+## Why this and not generic RAG?
+
+Most "RAG libraries" hand the agent `search(query) → list[chunk]` and stop. kglite-docs treats the corpus as a *living* knowledge graph that records who did what — and gives the agent typed tools to act on it.
+
+- 📄 **Multi-format ingest** — PDF, DOCX, PPTX, MD, HTML, TXT, images. All flow into the same `Document → Page → Chunk` shape.
+- 🤝 **Agents are first-class nodes** — their views, tags, summaries, verifications, and reviews are all queryable.
+- ✅ **Cross-checked summaries** — one agent writes, a *different* agent verifies. Self-verification is rejected server-side.
+- 📋 **Review kanban** — chunks move through `new → in_review → reviewed` with an immutable audit trail.
+- 🛡️ **Grounding checks** — score how well an agent's summary aligns with its sources. Catch hallucinations before they ship.
+- 🌍 **Translations** — per-chunk, multi-translator, with author/reviewer provenance.
+- 🖼️ **Agent-driven OCR** — scanned pages handed back as rendered PNGs; agent transcribes and the graph absorbs the result.
+
+## Install
+
+```bash
+pip install "kglite-docs[mcp]"
+```
+
+## 30 seconds of Python
+
+```python
+from kglite_docs import Corpus
+
+with Corpus.create("kb.kgl") as corpus:           # auto-saves on exit
+    corpus.ingest_dir("./papers")                  # PDF / DOCX / PPTX / MD / HTML / images
+    hits = corpus.search("transformer attention", top_k=5, agent_id="me")
+    ctx = corpus.compose_context("transformer attention", max_tokens=3000)
+    # ctx["items"] is a ranked, token-budgeted bundle ready for your LLM prompt
+```
+
+## 30 seconds of agent loop
+
+Cross-checked enrichment in five lines:
+
+```python
+sid = corpus.add_summary(
+    target_id=hits[0]["id"], text="DPR uses a dual BERT encoder…",
+    agent_id="writer", model="opus-4.7",
+)
+# A different agent verifies — self-verification is rejected
+corpus.verify_summary(sid, verdict="verified",
+                      verifier_agent_id="reviewer", notes="checked p.5")
+# Score how grounded the summary is in its source chunks
+print(corpus.check_grounding(sid)["supported_fraction"])    # → 1.0
+```
+
+## Run it as an MCP server
+
+```bash
+kglite-docs-mcp --db kb.kgl
+```
+
+Register with Claude Code:
+
+```bash
+claude mcp add kglite-docs -- kglite-docs-mcp --db /abs/path/kb.kgl
+```
+
+The agent now sees ~30 typed tools (`search`, `compose_context`, `add_summary`, `verify_summary`, `tag_chunk`, `cluster_chunks`, `claim_next_review`, …) plus `cypher_query` as an escape hatch.
+
+## Read the docs
+
+📖 **Full documentation at [kglite-docs.readthedocs.io](https://kglite-docs.readthedocs.io/)**
+
+- [Getting started](https://kglite-docs.readthedocs.io/en/latest/getting-started/) — 10 minutes from `pip install` to a running agent
+- [Agent workflows](https://kglite-docs.readthedocs.io/en/latest/workflows/) — research, comparison, fact-checking, OCR loops, hallucination guards
+- [Architecture](https://kglite-docs.readthedocs.io/en/latest/architecture/) — graph model, design rationale, the 30+ typed MCP tools
+- [API reference](https://kglite-docs.readthedocs.io/en/latest/api/corpus/) — every method, every argument, IDE-friendly type stubs
+- [Troubleshooting](https://kglite-docs.readthedocs.io/en/latest/troubleshooting/) — common failure modes
+- [Changelog](https://kglite-docs.readthedocs.io/en/latest/changelog/)
+
+## License
+
+MIT.

kglite_docs-0.0.1/README.md

@@ -0,0 +1,87 @@
+# kglite-docs
+
+> **Agent-first knowledge base for documents.** Ingest PDFs, Office files, Markdown, HTML, or images; chunk + embed them with [BAAI/bge-m3](https://huggingface.co/BAAI/bge-m3); cluster, tag, summarise, fact-check, translate, and review them — and serve the whole thing to AI agents over MCP.
+
+[![PyPI](https://img.shields.io/pypi/v/kglite-docs.svg)](https://pypi.org/project/kglite-docs/)
+[![Python](https://img.shields.io/pypi/pyversions/kglite-docs.svg)](https://pypi.org/project/kglite-docs/)
+[![Docs](https://readthedocs.org/projects/kglite-docs/badge/?version=latest)](https://kglite-docs.readthedocs.io/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Built on [`kglite`](https://github.com/kkollsga/kglite) (storage + vector search + clustering) and [`mcp-methods`](https://github.com/kkollsga/mcp-methods) (MCP framework).
+
+---
+
+## Why this and not generic RAG?
+
+Most "RAG libraries" hand the agent `search(query) → list[chunk]` and stop. kglite-docs treats the corpus as a *living* knowledge graph that records who did what — and gives the agent typed tools to act on it.
+
+- 📄 **Multi-format ingest** — PDF, DOCX, PPTX, MD, HTML, TXT, images. All flow into the same `Document → Page → Chunk` shape.
+- 🤝 **Agents are first-class nodes** — their views, tags, summaries, verifications, and reviews are all queryable.
+- ✅ **Cross-checked summaries** — one agent writes, a *different* agent verifies. Self-verification is rejected server-side.
+- 📋 **Review kanban** — chunks move through `new → in_review → reviewed` with an immutable audit trail.
+- 🛡️ **Grounding checks** — score how well an agent's summary aligns with its sources. Catch hallucinations before they ship.
+- 🌍 **Translations** — per-chunk, multi-translator, with author/reviewer provenance.
+- 🖼️ **Agent-driven OCR** — scanned pages handed back as rendered PNGs; agent transcribes and the graph absorbs the result.
+
+## Install
+
+```bash
+pip install "kglite-docs[mcp]"
+```
+
+## 30 seconds of Python
+
+```python
+from kglite_docs import Corpus
+
+with Corpus.create("kb.kgl") as corpus:           # auto-saves on exit
+    corpus.ingest_dir("./papers")                  # PDF / DOCX / PPTX / MD / HTML / images
+    hits = corpus.search("transformer attention", top_k=5, agent_id="me")
+    ctx = corpus.compose_context("transformer attention", max_tokens=3000)
+    # ctx["items"] is a ranked, token-budgeted bundle ready for your LLM prompt
+```
+
+## 30 seconds of agent loop
+
+Cross-checked enrichment in five lines:
+
+```python
+sid = corpus.add_summary(
+    target_id=hits[0]["id"], text="DPR uses a dual BERT encoder…",
+    agent_id="writer", model="opus-4.7",
+)
+# A different agent verifies — self-verification is rejected
+corpus.verify_summary(sid, verdict="verified",
+                      verifier_agent_id="reviewer", notes="checked p.5")
+# Score how grounded the summary is in its source chunks
+print(corpus.check_grounding(sid)["supported_fraction"])    # → 1.0
+```
+
+## Run it as an MCP server
+
+```bash
+kglite-docs-mcp --db kb.kgl
+```
+
+Register with Claude Code:
+
+```bash
+claude mcp add kglite-docs -- kglite-docs-mcp --db /abs/path/kb.kgl
+```
+
+The agent now sees ~30 typed tools (`search`, `compose_context`, `add_summary`, `verify_summary`, `tag_chunk`, `cluster_chunks`, `claim_next_review`, …) plus `cypher_query` as an escape hatch.
+
+## Read the docs
+
+📖 **Full documentation at [kglite-docs.readthedocs.io](https://kglite-docs.readthedocs.io/)**
+
+- [Getting started](https://kglite-docs.readthedocs.io/en/latest/getting-started/) — 10 minutes from `pip install` to a running agent
+- [Agent workflows](https://kglite-docs.readthedocs.io/en/latest/workflows/) — research, comparison, fact-checking, OCR loops, hallucination guards
+- [Architecture](https://kglite-docs.readthedocs.io/en/latest/architecture/) — graph model, design rationale, the 30+ typed MCP tools
+- [API reference](https://kglite-docs.readthedocs.io/en/latest/api/corpus/) — every method, every argument, IDE-friendly type stubs
+- [Troubleshooting](https://kglite-docs.readthedocs.io/en/latest/troubleshooting/) — common failure modes
+- [Changelog](https://kglite-docs.readthedocs.io/en/latest/changelog/)
+
+## License
+
+MIT.

kglite_docs-0.0.1/pyproject.toml

@@ -0,0 +1,113 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "kglite-docs"
+# Bump this and push to main — the release.yml workflow checks PyPI
+# and publishes if the version is new. No git tag needed.
+version = "0.0.1"
+description = "Agent-first PDF knowledge base — chunk, embed, cluster, enrich, and serve over MCP. Built on kglite + bge-m3."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "Kristian dF Kollsgård", email = "kkollsg@gmail.com" },
+]
+requires-python = ">=3.10"
+keywords = ["pdf", "rag", "embeddings", "knowledge-graph", "mcp", "kglite", "bge-m3"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "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 :: Scientific/Engineering :: Information Analysis",
+    "Topic :: Text Processing :: Indexing",
+]
+dependencies = [
+    "kglite>=0.10.4",
+    "pymupdf4llm>=0.0.17",
+    "pymupdf>=1.24",
+    "tokenizers>=0.20",
+    "huggingface-hub>=0.26",
+    "onnxruntime>=1.18",
+    "numpy>=1.26",
+    "pandas>=2.0",
+    "python-docx>=1.0",
+    "python-pptx>=0.6",
+    "markdownify>=0.13",
+    "reportlab>=4.0",
+]
+
+[project.optional-dependencies]
+mcp = [
+    "mcp>=1.0",
+    "mcp-methods>=0.3",
+]
+dev = [
+    "pytest>=8.0",
+    "pytest-cov>=5.0",
+    "ruff>=0.7",
+    "mypy>=1.13",
+]
+docs = [
+    "mkdocs>=1.6",
+    "mkdocs-material>=9.5",
+    "mkdocstrings[python]>=0.27",
+]
+
+[project.scripts]
+kglite-docs = "kglite_docs.cli:main"
+kglite-docs-mcp = "kglite_docs.mcp_server.__main__:main"
+
+[project.urls]
+Homepage = "https://github.com/kkollsga/kglite-docs"
+Repository = "https://github.com/kkollsga/kglite-docs"
+Issues = "https://github.com/kkollsga/kglite-docs/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/kglite_docs"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "src/kglite_docs",
+    "tests",
+    "README.md",
+    "LICENSE",
+    "pyproject.toml",
+]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B", "UP", "W", "N", "SIM"]
+ignore = ["E501"]
+
+[tool.ruff.lint.per-file-ignores]
+# Scientific code uses `X` for the feature matrix (sklearn convention)
+"src/kglite_docs/cluster.py" = ["N803", "N806"]
+# Public exception API — `ReviewConflict` reads better than
+# `ReviewConflictError` and is already exported through __init__.
+"src/kglite_docs/errors.py" = ["N818"]
+# Tests are allowed semicolons for compact setup lines.
+"tests/*" = ["E702"]
+
+[tool.mypy]
+python_version = "3.10"
+strict = true
+warn_unused_ignores = true
+exclude = ["tests/", "build/", "dist/"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-ra -q"
+markers = [
+    "embed: tests that require the real bge-m3 model (slow; skipped if model not available)",
+    "mcp: tests that exercise the MCP server surface",
+]

kglite_docs-0.0.1/src/kglite_docs/__init__.py

@@ -0,0 +1,62 @@
+"""kglite-docs — agent-first PDF knowledge base on top of kglite."""
+
+from __future__ import annotations
+
+from kglite_docs.corpus import Corpus
+from kglite_docs.errors import (
+    ConcurrencyError,
+    GroundingError,
+    IngestError,
+    InvalidEnumError,
+    KgliteDocsError,
+    MissingSourceError,
+    ReviewConflict,
+    SelfVerificationError,
+    UnsupportedFormatError,
+)
+from kglite_docs.schema import (
+    AGENT,
+    CHUNK,
+    CHUNK_TEXT_EMB,
+    CLUSTER,
+    DOCUMENT,
+    DOCUMENT_TITLE_EMB,
+    NOTE,
+    PAGE,
+    SUMMARY,
+    SUMMARY_TEXT_EMB,
+    TAG,
+    VIEW,
+)
+
+try:
+    from importlib.metadata import version as _pkg_version
+    __version__ = _pkg_version("kglite-docs")
+except Exception:  # pragma: no cover - not installed (e.g. running from source)
+    __version__ = "0.0.0+local"
+
+__all__ = [
+    "AGENT",
+    "CHUNK",
+    "CHUNK_TEXT_EMB",
+    "CLUSTER",
+    "DOCUMENT",
+    "DOCUMENT_TITLE_EMB",
+    "NOTE",
+    "PAGE",
+    "SUMMARY",
+    "SUMMARY_TEXT_EMB",
+    "TAG",
+    "VIEW",
+    "ConcurrencyError",
+    "Corpus",
+    "GroundingError",
+    "IngestError",
+    "InvalidEnumError",
+    "KgliteDocsError",
+    "MissingSourceError",
+    "ReviewConflict",
+    "SelfVerificationError",
+    "UnsupportedFormatError",
+    "__version__",
+]

kglite_docs-0.0.1/src/kglite_docs/activity.py

@@ -0,0 +1,146 @@
+"""Agent identity + view tracking.
+
+Agents are lazily registered on their first mutation; views can be
+recorded explicitly (with context) or implicitly (when `search` /
+`get_chunk` are called with an `agent_id`).
+
+Aggregate `view_count` + `last_viewed_at` on the Chunk is updated on
+every recorded view — a cheap denormalisation so listings can sort by
+attention without joining View nodes.
+"""
+
+from __future__ import annotations
+
+import uuid
+from datetime import datetime, timezone
+from typing import Any
+
+from kglite_docs.schema import (
+    AGENT,
+    AUTHORED,
+    CHUNK,
+    VIEW,
+    VIEWED,
+)
+from kglite_docs.store import Store
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+from kglite_docs.store import rows as _df_dicts  # noqa: E402
+
+
+def register_agent(
+    store: Store, *, agent_id: str, kind: str = "llm", model: str = ""
+) -> dict[str, Any]:
+    """Idempotent. Touches `last_seen` if the agent exists; creates otherwise."""
+    now = _now()
+    existing = _df_dicts(
+        store.cypher("MATCH (a:Agent {id: $id}) RETURN a.id AS id", params={"id": agent_id})
+    )
+    if existing:
+        store.cypher(
+            "MATCH (a:Agent {id: $id}) SET a.last_seen = $now, a.action_count = coalesce(a.action_count, 0) + 1",
+            params={"id": agent_id, "now": now},
+        )
+        return {"id": agent_id, "created": False, "last_seen": now}
+    store.upsert_nodes(
+        AGENT,
+        [{
+            "id": agent_id,
+            "title": agent_id,
+            "kind": kind,
+            "model": model,
+            "first_seen": now,
+            "last_seen": now,
+            "action_count": 1,
+        }],
+    )
+    return {"id": agent_id, "created": True, "last_seen": now}
+
+
+def list_agents(store: Store) -> list[dict[str, Any]]:
+    df = store.cypher(
+        "MATCH (a:Agent) RETURN a.id AS id, a.kind AS kind, a.model AS model, "
+        "a.first_seen AS first_seen, a.last_seen AS last_seen, a.action_count AS actions "
+        "ORDER BY a.last_seen DESC"
+    )
+    return _df_dicts(df)
+
+
+def record_view(
+    store: Store,
+    *,
+    agent_id: str,
+    target_id: str,
+    target_kind: str = CHUNK,
+    context: str = "",
+) -> dict[str, Any]:
+    """Record an agent viewing a target. Lazy-registers the agent.
+
+    - Always bumps the target's `view_count` and `last_viewed_at`.
+    - Creates a `View` node + edges when `context` is non-empty (so we
+      can surface "the query that led here" later); pure visits skip
+      the View node to keep the graph lean.
+    """
+    register_agent(store, agent_id=agent_id)
+    now = _now()
+    if target_kind == CHUNK:
+        store.cypher(
+            "MATCH (c:Chunk {id: $id}) "
+            "SET c.view_count = coalesce(c.view_count, 0) + 1, c.last_viewed_at = $now",
+            params={"id": target_id, "now": now},
+        )
+    if not context:
+        return {"recorded": True, "view_node": None}
+    vid = str(uuid.uuid4())
+    store.upsert_nodes(
+        VIEW,
+        [{
+            "id": vid,
+            "title": context[:60],
+            "agent_id": agent_id,
+            "target_id": target_id,
+            "target_kind": target_kind,
+            "at": now,
+            "context": context,
+        }],
+    )
+    store.upsert_edges(
+        AUTHORED, [{"src": agent_id, "dst": vid}],
+        source_type=AGENT, target_type=VIEW,
+    )
+    # Aggregate VIEWED edge (Agent → Chunk) — multiple writes are tolerated;
+    # we don't need uniqueness here.
+    if target_kind == CHUNK:
+        store.upsert_edges(
+            VIEWED, [{"src": agent_id, "dst": target_id, "at": now, "context": context}],
+            source_type=AGENT, target_type=CHUNK,
+        )
+    return {"recorded": True, "view_node": vid}
+
+
+def agent_activity(store: Store, agent_id: str, *, limit: int = 50) -> dict[str, Any]:
+    """Return summary + recent activity for an agent."""
+    a_df = _df_dicts(store.cypher(
+        "MATCH (a:Agent {id: $id}) RETURN a.id AS id, a.kind AS kind, "
+        "a.first_seen AS first_seen, a.last_seen AS last_seen, a.action_count AS actions",
+        params={"id": agent_id},
+    ))
+    if not a_df:
+        return {"agent": None, "views": [], "summaries": [], "tags": []}
+    views = _df_dicts(store.cypher(
+        "MATCH (a:Agent {id: $id})-[:AUTHORED]->(v:View) "
+        f"RETURN v.target_id AS target_id, v.target_kind AS target_kind, v.context AS context, v.at AS at "
+        f"ORDER BY v.at DESC LIMIT {int(limit)}",
+        params={"id": agent_id},
+    ))
+    sums = _df_dicts(store.cypher(
+        "MATCH (a:Agent {id: $id})-[:AUTHORED]->(s:Summary) "
+        f"RETURN s.id AS id, s.target_id AS target_id, s.text AS text, s.verification_status AS status "
+        f"ORDER BY s.created_at DESC LIMIT {int(limit)}",
+        params={"id": agent_id},
+    ))
+    return {"agent": a_df[0], "views": views, "summaries": sums}