agentgraph-server 0.7.0__tar.gz → 0.7.2__tar.gz

{agentgraph_server-0.7.0 → agentgraph_server-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentgraph-server
-Version: 0.7.0
+Version: 0.7.2
 Summary: A local-first CLI and MCP server that turns selected digital sources into a searchable graph for the AI agent you already use.
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
@@ -100,8 +100,8 @@ These connectors are proof of the pattern, not the boundary of the product. A co
 AgentGraph requires Python 3.12+, [`uv`](https://docs.astral.sh/uv/), and Chrome for browser observation.
 
 ```bash
-git clone https://github.com/simonexmachina/agent-graph
-cd agent-graph
+git clone https://github.com/simonexmachina/agentgraph
+cd agentgraph
 uv sync --extra all
 source .venv/bin/activate
 agentgraph onboard

{agentgraph_server-0.7.0 → agentgraph_server-0.7.2}/README.md

@@ -59,8 +59,8 @@ These connectors are proof of the pattern, not the boundary of the product. A co
 AgentGraph requires Python 3.12+, [`uv`](https://docs.astral.sh/uv/), and Chrome for browser observation.
 
 ```bash
-git clone https://github.com/simonexmachina/agent-graph
-cd agent-graph
+git clone https://github.com/simonexmachina/agentgraph
+cd agentgraph
 uv sync --extra all
 source .venv/bin/activate
 agentgraph onboard

{agentgraph_server-0.7.0 → agentgraph_server-0.7.2}/agentgraph/backends/sqlite/backend.py

@@ -93,6 +93,22 @@ def _new_id() -> str:
     return str(uuid.uuid4())
 
 
+def _content_projection(
+    content_limit: int | None, column: str = "content"
+) -> tuple[str, list[int]]:
+    """Return SQL that bounds content before it leaves SQLite."""
+    if content_limit is None:
+        return column, []
+    if content_limit < 1:
+        raise ValueError("content_limit must be at least 1")
+    return (
+        f"CASE WHEN length({column}) > ? THEN substr({column}, 1, ?) || '…' "
+        f"ELSE {column} END AS content, "
+        f"CASE WHEN length({column}) > ? THEN 1 ELSE 0 END AS content_truncated",
+        [content_limit, content_limit - 1, content_limit],
+    )
+
+
 def _entity_predicates(
     entity_types: list[str] | None = None,
     platform: str | None = None,
@@ -1252,6 +1268,7 @@ class SQLiteBackend(StorageBackend):
         authored_by: list[str] | None = None,
         has_attachments: bool = False,
         order_by: str | None = None,
+        content_limit: int | None = None,
     ) -> list[EntityResult]:
         """Select entities by predicate, ranked by relevance or ordered by date.
 
@@ -1279,6 +1296,7 @@ class SQLiteBackend(StorageBackend):
                 join_params,
                 limit,
                 order_by,
+                content_limit,
             )
 
         with timed("sqlite.search_entities", limit=limit, platform=platform):
@@ -1367,17 +1385,18 @@ class SQLiteBackend(StorageBackend):
             id_list = [eid for eid, _ in top]
             score_map = {eid: sc for eid, sc in top}
             placeholders = ",".join("?" * len(id_list))
+            content_column, content_params = _content_projection(content_limit)
             with timed("sqlite.search.hydrate", count=len(id_list)):
                 cursor = await conn.execute(
                     f"""
                     SELECT id, entity_type, platform, platform_entity_id,
-                           title, content, metadata, created_at, updated_at,
+                           title, {content_column}, metadata, created_at, updated_at,
                            source_created_at, source_updated_at, synced_at, observed_at,
                            retention_policy, retention_parent_id,
                            cumulative_observation_duration_ms, bookmarked
                     FROM entities WHERE id IN ({placeholders})
                     """,
-                    id_list,
+                    [*content_params, *id_list],
                 )
                 rows = await cursor.fetchall()
                 results: list[dict[str, Any]] = []
@@ -1415,15 +1434,17 @@ class SQLiteBackend(StorageBackend):
         join_params: list[Any],
         limit: int,
         order_by: str | None,
+        content_limit: int | None,
     ) -> list[EntityResult]:
         """Return entities matching the predicates alone, newest first."""
         if order_by not in _VALID_ORDER_BY:
             order_by = "observed_at"
+        content_column, content_params = _content_projection(content_limit, "e.content")
         with timed("sqlite.select_entities", order_by=order_by, limit=limit):
             rows = await self._fetchall(
                 f"""
                 SELECT e.id, e.entity_type, e.platform, e.platform_entity_id,
-                       e.title, e.content, e.metadata, e.created_at, e.updated_at,
+                       e.title, {content_column}, e.metadata, e.created_at, e.updated_at,
                        e.source_created_at, e.source_updated_at,
                        e.synced_at, e.observed_at,
                        e.retention_policy, e.retention_parent_id,
@@ -1434,38 +1455,44 @@ class SQLiteBackend(StorageBackend):
                 ORDER BY e.{order_by} DESC
                 LIMIT ?
                 """,
-                [*join_params, *where_params, limit],
+                [*content_params, *join_params, *where_params, limit],
             )
         return [_row_to_entity(row) for row in rows]
 
-    async def get_entity_by_id(self, entity_id: str) -> EntityResult | None:
+    async def get_entity_by_id(
+        self, entity_id: str, content_limit: int | None = None
+    ) -> EntityResult | None:
+        content_column, content_params = _content_projection(content_limit)
         row = await self._fetchone(
-            """
+            f"""
             SELECT id, entity_type, platform, platform_entity_id,
-                   title, content, metadata, created_at, updated_at,
+                   title, {content_column}, metadata, created_at, updated_at,
                    source_created_at, source_updated_at, synced_at, observed_at,
                    retention_policy, retention_parent_id,
                    cumulative_observation_duration_ms, bookmarked
             FROM entities WHERE id = ?
             """,
-            [entity_id],
+            [*content_params, entity_id],
         )
         return _row_to_entity(row) if row else None
 
-    async def get_entities_by_ids(self, entity_ids: list[str]) -> list[EntityResult]:
+    async def get_entities_by_ids(
+        self, entity_ids: list[str], content_limit: int | None = None
+    ) -> list[EntityResult]:
         if not entity_ids:
             return []
         placeholders = ",".join("?" * len(entity_ids))
+        content_column, content_params = _content_projection(content_limit)
         rows = await self._fetchall(
             f"""
             SELECT id, entity_type, platform, platform_entity_id,
-                   title, content, metadata, created_at, updated_at,
+                   title, {content_column}, metadata, created_at, updated_at,
                    source_created_at, source_updated_at, synced_at, observed_at,
                    retention_policy, retention_parent_id,
                    cumulative_observation_duration_ms, bookmarked
             FROM entities WHERE id IN ({placeholders})
             """,
-            entity_ids,
+            [*content_params, *entity_ids],
         )
         return [_row_to_entity(r) for r in rows]
 
@@ -1476,33 +1503,40 @@ class SQLiteBackend(StorageBackend):
         by_id = {str(entity["id"]): entity for entity in entities}
         return [by_id[entity_id] for entity_id in entity_ids if entity_id in by_id]
 
-    async def get_entities_by_id_prefix(self, prefix: str) -> list[EntityResult]:
+    async def get_entities_by_id_prefix(
+        self, prefix: str, content_limit: int | None = None
+    ) -> list[EntityResult]:
+        content_column, content_params = _content_projection(content_limit)
         rows = await self._fetchall(
-            """
+            f"""
             SELECT id, entity_type, platform, platform_entity_id,
-                   title, content, metadata, created_at, updated_at,
+                   title, {content_column}, metadata, created_at, updated_at,
                    source_created_at, source_updated_at, synced_at, observed_at,
                    retention_policy, retention_parent_id,
                    cumulative_observation_duration_ms, bookmarked
             FROM entities WHERE id LIKE ?
             """,
-            [f"{prefix}%"],
+            [*content_params, f"{prefix}%"],
         )
         return [_row_to_entity(row) for row in rows]
 
     async def get_entity_by_platform(
-        self, platform: str, platform_entity_id: str
+        self,
+        platform: str,
+        platform_entity_id: str,
+        content_limit: int | None = None,
     ) -> EntityResult | None:
+        content_column, content_params = _content_projection(content_limit)
         row = await self._fetchone(
-            """
+            f"""
             SELECT id, entity_type, platform, platform_entity_id,
-                   title, content, metadata, created_at, updated_at,
+                   title, {content_column}, metadata, created_at, updated_at,
                    source_created_at, source_updated_at, synced_at, observed_at,
                    retention_policy, retention_parent_id,
                    cumulative_observation_duration_ms, bookmarked
             FROM entities WHERE platform = ? AND platform_entity_id = ?
             """,
-            [platform, platform_entity_id],
+            [*content_params, platform, platform_entity_id],
         )
         return _row_to_entity(row) if row else None
 
@@ -1512,6 +1546,7 @@ class SQLiteBackend(StorageBackend):
         platform: str | None,
         since: datetime | None,
         limit: int,
+        content_limit: int | None = None,
     ) -> list[EntityResult]:
         clauses: list[str] = []
         params: list[Any] = []
@@ -1527,10 +1562,11 @@ class SQLiteBackend(StorageBackend):
             params.append(_utc_stamp(since))
         where = ("WHERE " + " AND ".join(clauses)) if clauses else ""
         params.append(limit)
+        content_column, content_params = _content_projection(content_limit)
         rows = await self._fetchall(
             f"""
             SELECT id, entity_type, platform, platform_entity_id,
-                   title, content, metadata, created_at, updated_at,
+                   title, {content_column}, metadata, created_at, updated_at,
                    source_created_at, source_updated_at, synced_at, observed_at,
                    retention_policy, retention_parent_id,
                    cumulative_observation_duration_ms, bookmarked
@@ -1539,7 +1575,7 @@ class SQLiteBackend(StorageBackend):
             ORDER BY observed_at DESC
             LIMIT ?
             """,
-            params,
+            [*content_params, *params],
         )
         return [_row_to_entity(row) for row in rows]
 
@@ -1552,6 +1588,7 @@ class SQLiteBackend(StorageBackend):
         offset: int,
         order_by: str | None,
         order_dir: str,
+        content_limit: int | None = None,
     ) -> tuple[list[EntityResult], int]:
         order_by_sql = (
             _LIST_PAGE_ORDER_BY.get(order_by, "observed_at") if order_by is not None else None
@@ -1578,10 +1615,11 @@ class SQLiteBackend(StorageBackend):
 
         count_row = await self._fetchone(f"SELECT COUNT(*) AS count FROM entities {where}", params)
         total = int(count_row["count"]) if count_row else 0
+        content_column, content_params = _content_projection(content_limit)
         rows = await self._fetchall(
             f"""
             SELECT id, entity_type, platform, platform_entity_id,
-                   title, content, metadata, created_at, updated_at,
+                   title, {content_column}, metadata, created_at, updated_at,
                    source_created_at, source_updated_at, synced_at, observed_at,
                    retention_policy, retention_parent_id,
                    cumulative_observation_duration_ms, bookmarked
@@ -1590,7 +1628,7 @@ class SQLiteBackend(StorageBackend):
             {order_clause}
             LIMIT ? OFFSET ?
             """,
-            [*params, limit, offset],
+            [*content_params, *params, limit, offset],
         )
         return [_row_to_entity(row) for row in rows], total
 
@@ -1603,6 +1641,7 @@ class SQLiteBackend(StorageBackend):
         since: datetime | None,
         authored_by: list[str] | None,
         has_attachments: bool = False,
+        content_limit: int | None = None,
     ) -> list[EntityResult]:
         """Single-type filtered read, for connectors that hold the backend directly."""
         return await self.search_entities(
@@ -1616,6 +1655,7 @@ class SQLiteBackend(StorageBackend):
             authored_by=authored_by,
             has_attachments=has_attachments,
             order_by=order_by,
+            content_limit=content_limit,
         )
 
     async def list_recent_metadata_by_edge_target(
@@ -1740,8 +1780,11 @@ class SQLiteBackend(StorageBackend):
         )
         return [_row_to_edge(row) for row in rows]
 
-    async def traverse_graph(self, entity_id: str, max_depth: int) -> dict[str, Any]:
+    async def traverse_graph(
+        self, entity_id: str, max_depth: int, content_limit: int | None = None
+    ) -> dict[str, Any]:
         conn = self._read_conn_or_raise()
+        content_column, content_params = _content_projection(content_limit)
         visited: set[str] = set()
         frontier: list[str] = [entity_id]
         all_nodes: list[EntityResult] = []
@@ -1755,13 +1798,13 @@ class SQLiteBackend(StorageBackend):
             cursor = await conn.execute(
                 f"""
                 SELECT id, entity_type, platform, platform_entity_id,
-                       title, content, metadata, created_at, updated_at,
+                       title, {content_column}, metadata, created_at, updated_at,
                        source_created_at, source_updated_at, synced_at, observed_at,
                        retention_policy, retention_parent_id,
                        cumulative_observation_duration_ms, bookmarked
                 FROM entities WHERE id IN ({placeholders})
                 """,
-                frontier,
+                [*content_params, *frontier],
             )
             for row in await cursor.fetchall():
                 eid = row["id"]
@@ -1802,13 +1845,13 @@ class SQLiteBackend(StorageBackend):
             cursor = await conn.execute(
                 f"""
                 SELECT id, entity_type, platform, platform_entity_id,
-                       title, content, metadata, created_at, updated_at,
+                       title, {content_column}, metadata, created_at, updated_at,
                        source_created_at, source_updated_at, synced_at, observed_at,
                        retention_policy, retention_parent_id,
                        cumulative_observation_duration_ms, bookmarked
                 FROM entities WHERE id IN ({placeholders})
                 """,
-                unvisited,
+                [*content_params, *unvisited],
             )
             for row in await cursor.fetchall():
                 all_nodes.append(_row_to_entity(row))
@@ -2107,7 +2150,7 @@ class SQLiteBackend(StorageBackend):
 
 def _row_to_entity(row: Any) -> EntityResult:
     keys = row.keys() if hasattr(row, "keys") else []
-    return {
+    entity: EntityResult = {
         "id": row["id"],
         "entity_type": row["entity_type"],
         "platform": row["platform"],
@@ -2131,6 +2174,9 @@ def _row_to_entity(row: Any) -> EntityResult:
         "bookmarked": bool(row["bookmarked"]) if "bookmarked" in keys else False,
         "score": row["score"] if "score" in keys else None,
     }
+    if "content_truncated" in keys:
+        entity["content_truncated"] = bool(row["content_truncated"])
+    return entity
 
 
 def _row_to_edge(row: Any) -> EdgeResult:

{agentgraph_server-0.7.0 → agentgraph_server-0.7.2}/agentgraph/cli.py

@@ -914,5 +914,3 @@ def poll(
     from agentgraph.cli_sync import cmd_poll
 
     cmd_poll(source=source, as_json=json)
-
-

{agentgraph_server-0.7.0 → agentgraph_server-0.7.2}/agentgraph/core/storage.py

@@ -92,6 +92,7 @@ class StorageBackend(ABC):
         authored_by: list[str] | None = None,
         has_attachments: bool = False,
         order_by: str | None = None,
+        content_limit: int | None = None,
     ) -> list[EntityResult]:
         """Select entities by predicate, ranked by relevance or ordered by date.
 
@@ -103,17 +104,26 @@ class StorageBackend(ABC):
         ...
 
     @abstractmethod
-    async def get_entity_by_id(self, entity_id: str) -> EntityResult | None: ...
+    async def get_entity_by_id(
+        self, entity_id: str, content_limit: int | None = None
+    ) -> EntityResult | None: ...
 
     @abstractmethod
-    async def get_entities_by_ids(self, entity_ids: list[str]) -> list[EntityResult]: ...
+    async def get_entities_by_ids(
+        self, entity_ids: list[str], content_limit: int | None = None
+    ) -> list[EntityResult]: ...
 
     @abstractmethod
-    async def get_entities_by_id_prefix(self, prefix: str) -> list[EntityResult]: ...
+    async def get_entities_by_id_prefix(
+        self, prefix: str, content_limit: int | None = None
+    ) -> list[EntityResult]: ...
 
     @abstractmethod
     async def get_entity_by_platform(
-        self, platform: str, platform_entity_id: str
+        self,
+        platform: str,
+        platform_entity_id: str,
+        content_limit: int | None = None,
     ) -> EntityResult | None: ...
 
     @abstractmethod
@@ -123,6 +133,7 @@ class StorageBackend(ABC):
         platform: str | None,
         since: datetime | None,
         limit: int,
+        content_limit: int | None = None,
     ) -> list[EntityResult]: ...
 
     @abstractmethod
@@ -135,6 +146,7 @@ class StorageBackend(ABC):
         offset: int,
         order_by: str | None,
         order_dir: str,
+        content_limit: int | None = None,
     ) -> tuple[list[EntityResult], int]:
         """Return an entity page and total count, optionally ordered by a supported field."""
         ...
@@ -149,6 +161,7 @@ class StorageBackend(ABC):
         since: datetime | None,
         authored_by: list[str] | None,
         has_attachments: bool = False,
+        content_limit: int | None = None,
     ) -> list[EntityResult]:
         """Single-type filtered read, kept for connectors that hold a backend directly.
 
@@ -184,7 +197,7 @@ class StorageBackend(ABC):
 
     @abstractmethod
     async def traverse_graph(
-        self, entity_id: str, max_depth: int
+        self, entity_id: str, max_depth: int, content_limit: int | None = None
     ) -> dict[str, Any]: ...
 
     # --- Linking ---

{agentgraph_server-0.7.0 → agentgraph_server-0.7.2}/agentgraph/demo.py

@@ -15,11 +15,11 @@ DEMO_FIXTURE_METADATA_KEY = "_agentgraph_fixture"
 DEMO_FIXTURE_METADATA_VALUE = "atlas-demo"
 DEMO_CREATED_AT = "2026-08-14T08:00:00Z"
 WEBHOOK_ARTICLE_URL = (
-    "https://github.com/simonexmachina/agent-graph/blob/main/"
+    "https://github.com/simonexmachina/agentgraph/blob/main/"
     "agentgraph/demo_fixtures/reliable-webhooks.md"
 )
 RETRY_GUIDE_URL = (
-    "https://github.com/simonexmachina/agent-graph/blob/main/"
+    "https://github.com/simonexmachina/agentgraph/blob/main/"
     "agentgraph/demo_fixtures/retry-guidance.md"
 )
 

{agentgraph_server-0.7.0 → agentgraph_server-0.7.2}/agentgraph/graph/link.py

@@ -47,6 +47,13 @@ async def link_entity_to_urls(platform_entity_id: str, platform: str, content: s
             continue
         seen.add(ref.resource_id)
 
+        # An entity's own URL is normally part of its content — connectors append
+        # it to the rendered body, and a page or work item often links to itself
+        # from a comment. A self-loop carries no information, so it is dropped
+        # here rather than left for every caller to filter out of a traversal.
+        if ref.source == platform and ref.resource_id == platform_entity_id:
+            continue
+
         tgt_id = await backend.find_entity_id(ref.source, ref.resource_id)
         if not tgt_id:
             entity_type = RESOURCE_TYPE_TO_ENTITY_TYPE[ref.resource_type]

{agentgraph_server-0.7.0 → agentgraph_server-0.7.2}/agentgraph/graph/operations.py

@@ -22,6 +22,8 @@ def is_stub(entity: EntityResult) -> bool:
 def summarize_entity(entity: EntityResult, *, content_limit: int = 500) -> EntityResult:
     """Copy an entity and bound its content for list-style responses."""
     summarized = dict(entity)
+    if summarized.get("content_truncated") is True:
+        return summarized
     content = summarized.get("content")
     if isinstance(content, str) and len(content) > content_limit:
         summarized["content"] = content[: max(content_limit - 1, 0)].rstrip() + "…"
@@ -40,14 +42,25 @@ def summarize_entities(
     return [summarize_entity(entity, content_limit=content_limit) for entity in entities]
 
 
-async def resolve_entity(target: str) -> EntityResult | None:
+async def resolve_entity(
+    target: str, content_limit: int | None = None
+) -> EntityResult | None:
     """Resolve an existing entity from a UUID, prefix, platform ref, or URL."""
-    return await get_entity_by_url(target) if is_http_url(target) else await get_entity(target)
+    if is_http_url(target):
+        if content_limit is None:
+            return await get_entity_by_url(target)
+        return await get_entity_by_url(target, content_limit=content_limit)
+    return await get_entity(target, content_limit=content_limit)
 
 
-async def get_entity_details(target: str, *, resolve: bool = False) -> EntityResult | None:
+async def get_entity_details(
+    target: str,
+    *,
+    resolve: bool = False,
+    content_limit: int | None = None,
+) -> EntityResult | None:
     """Resolve an entity and optionally fetch it when it is still a stub."""
-    entity = await resolve_entity(target)
+    entity = await resolve_entity(target, content_limit=content_limit)
     if entity is None or not resolve or not is_stub(entity):
         return entity
     return await refresh_stub(entity)

{agentgraph_server-0.7.0 → agentgraph_server-0.7.2}/agentgraph/graph/query.py

@@ -62,6 +62,7 @@ async def search_entities(
     authored_by_me: bool = False,
     has_attachments: bool = False,
     order_by: str | None = None,
+    content_limit: int | None = None,
 ) -> list[EntityResult]:
     """Select entities by filter, ranked by hybrid relevance when a query is given.
 
@@ -93,12 +94,15 @@ async def search_entities(
         authored_by=authored_by,
         has_attachments=has_attachments,
         order_by=order_by,
+        content_limit=content_limit,
     )
     _enrich_web_url(results)
     return results
 
 
-async def get_entity(entity_id: str) -> EntityResult | None:
+async def get_entity(
+    entity_id: str, content_limit: int | None = None
+) -> EntityResult | None:
     """Fetch a single entity by UUID, unambiguous UUID prefix, or platform ref.
 
     Platform ref formats accepted:
@@ -108,15 +112,15 @@ async def get_entity(entity_id: str) -> EntityResult | None:
     backend = get_backend()
     entity: EntityResult | None
     if len(entity_id) == 36 or (len(entity_id) == 32 and "-" not in entity_id):
-        entity = await backend.get_entity_by_id(entity_id)
+        entity = await backend.get_entity_by_id(entity_id, content_limit=content_limit)
     elif "/" in entity_id:
         parts = entity_id.split("/")
         platform = parts[0]
         pid = "/".join(parts[2:]) if len(parts) >= 3 else "/".join(parts[1:])
-        entity = await backend.get_entity_by_platform(platform, pid)
+        entity = await backend.get_entity_by_platform(platform, pid, content_limit=content_limit)
     else:
         # UUID prefix — must be unambiguous
-        results = await backend.get_entities_by_id_prefix(entity_id)
+        results = await backend.get_entities_by_id_prefix(entity_id, content_limit=content_limit)
         if len(results) > 1:
             raise ValueError(
                 f"Ambiguous prefix {entity_id!r} matches {len(results)} entities"
@@ -127,7 +131,9 @@ async def get_entity(entity_id: str) -> EntityResult | None:
     return entity
 
 
-async def get_entity_by_url(url: str) -> EntityResult | None:
+async def get_entity_by_url(
+    url: str, content_limit: int | None = None
+) -> EntityResult | None:
     """Fetch a single existing entity by URL without fetching or creating it."""
     from agentgraph.connectors.registry import bootstrap, get_connector
     from agentgraph.server.router import classify_url, normalise_url_for_matching
@@ -138,7 +144,12 @@ async def get_entity_by_url(url: str) -> EntityResult | None:
     backend = get_backend()
 
     if ref is not None:
-        entity = await backend.get_entity_by_platform(ref.source, ref.resource_id)
+        if content_limit is None:
+            entity = await backend.get_entity_by_platform(ref.source, ref.resource_id)
+        else:
+            entity = await backend.get_entity_by_platform(
+                ref.source, ref.resource_id, content_limit=content_limit
+            )
         if entity is not None:
             _enrich_web_url([entity])
         return entity
@@ -148,9 +159,14 @@ async def get_entity_by_url(url: str) -> EntityResult | None:
     if web_ref is None:
         return None
 
-    entity = await backend.get_entity_by_platform(web_ref.source, web_ref.resource_id)
+    if content_limit is None:
+        entity = await backend.get_entity_by_platform(web_ref.source, web_ref.resource_id)
+    else:
+        entity = await backend.get_entity_by_platform(
+            web_ref.source, web_ref.resource_id, content_limit=content_limit
+        )
     if entity is None:
-        entity = await _get_entity_by_metadata_url(normalised_url)
+        entity = await _get_entity_by_metadata_url(normalised_url, content_limit=content_limit)
     if entity is not None:
         _enrich_web_url([entity])
     return entity
@@ -167,8 +183,11 @@ async def get_edges(
 async def traverse_graph(
     entity_id: str,
     max_depth: int = 2,
+    content_limit: int | None = None,
 ) -> dict[str, Any]:
-    return await get_backend().traverse_graph(entity_id, max_depth)
+    return await get_backend().traverse_graph(
+        entity_id, max_depth, content_limit=content_limit
+    )
 
 
 async def query_by_filter(
@@ -198,9 +217,12 @@ async def list_entities(
     platform: str | None = None,
     since: str | None = None,
     limit: int = 50,
+    content_limit: int | None = None,
 ) -> list[EntityResult]:
     since_dt = parse_since(since) if since else None
-    results = await get_backend().list_entities(entity_types, platform, since_dt, limit)
+    results = await get_backend().list_entities(
+        entity_types, platform, since_dt, limit, content_limit=content_limit
+    )
     _enrich_web_url(results)
     return results
 
@@ -213,10 +235,18 @@ async def list_entities_page(
     offset: int = 0,
     order_by: str | None = "observed_at",
     order_dir: str = "desc",
+    content_limit: int | None = None,
 ) -> tuple[list[EntityResult], int]:
     since_dt = parse_since(since) if since else None
     results, total = await get_backend().list_entities_page(
-        entity_types, platform, since_dt, limit, offset, order_by, order_dir
+        entity_types,
+        platform,
+        since_dt,
+        limit,
+        offset,
+        order_by,
+        order_dir,
+        content_limit=content_limit,
     )
     _enrich_web_url(results)
     return results, total
@@ -226,8 +256,10 @@ async def get_edges_for_entities(entity_ids: list[str]) -> list[EdgeResult]:
     return await get_backend().get_edges_for_entities(entity_ids)
 
 
-async def get_entities_by_ids(entity_ids: list[str]) -> list[EntityResult]:
-    results = await get_backend().get_entities_by_ids(entity_ids)
+async def get_entities_by_ids(
+    entity_ids: list[str], content_limit: int | None = None
+) -> list[EntityResult]:
+    results = await get_backend().get_entities_by_ids(entity_ids, content_limit=content_limit)
     _enrich_web_url(results)
     return results
 
@@ -243,18 +275,26 @@ def _resolve_me() -> list[str] | None:
     return user_ids or None
 
 
-async def _get_entity_by_metadata_url(url: str) -> EntityResult | None:
+async def _get_entity_by_metadata_url(
+    url: str, content_limit: int | None = None
+) -> EntityResult | None:
     """Find a document whose connector metadata identifies the browser URL."""
     backend = get_backend()
     for key in ("web_url", "url", "final_url"):
-        results = await backend.query_by_filter(
-            "Document",
-            {key: url},
-            1,
-            "updated_at",
-            None,
-            None,
-        )
+        if content_limit is None:
+            results = await backend.query_by_filter(
+                "Document", {key: url}, 1, "updated_at", None, None
+            )
+        else:
+            results = await backend.query_by_filter(
+                "Document",
+                {key: url},
+                1,
+                "updated_at",
+                None,
+                None,
+                content_limit=content_limit,
+            )
         if results:
             return results[0]
     return None