mindgraph-sdk 0.2.1__tar.gz → 0.3.0__tar.gz

{mindgraph_sdk-0.2.1 → mindgraph_sdk-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mindgraph-sdk
-Version: 0.2.1
+Version: 0.3.0
 Summary: Python client for the MindGraph Cloud API
 License-Expression: MIT
 Keywords: agent,ai,cognitive,knowledge-graph,mindgraph

{mindgraph_sdk-0.2.1 → mindgraph_sdk-0.3.0}/mindgraph/client.py

@@ -580,7 +580,16 @@ class MindGraph:
         node_type: str | None = None,
         layer: str | None = None,
         limit: int | None = None,
-    ) -> list[dict[str, Any]]:
+        min_score: float | None = None,
+        include_edges: bool = False,
+        include_chunks: bool = False,
+    ) -> list[dict[str, Any]] | dict[str, Any]:
+        """Full-text search over nodes.
+
+        When ``include_edges`` or ``include_chunks`` is True the response is an
+        enriched dict with ``results``, ``edges``, and ``chunks`` keys.
+        Otherwise a flat list of search results is returned.
+        """
         body: dict[str, Any] = {"query": query}
         if node_type:
             body["node_type"] = node_type
@@ -588,6 +597,12 @@ class MindGraph:
             body["layer"] = layer
         if limit:
             body["limit"] = limit
+        if min_score is not None:
+            body["min_score"] = min_score
+        if include_edges:
+            body["include_edges"] = True
+        if include_chunks:
+            body["include_chunks"] = True
         return self._request("POST", "/search", body)
 
     def hybrid_search(
@@ -914,31 +929,50 @@ class MindGraph:
         self,
         query: str,
         *,
-        k: int | None = None,
-        depth: int | None = None,
+        node_limit: int | None = None,
+        article_limit: int | None = None,
+        chunk_limit: int | None = None,
         node_types: list[str] | None = None,
         layer: str | None = None,
-        include_chunks: bool | None = None,
         include_graph: bool | None = None,
         min_similarity: float | None = None,
     ) -> dict[str, Any]:
+        """Retrieve context from the knowledge graph.
+
+        Returns articles (synthesized wiki summaries), graph nodes with
+        source_documents provenance, and optionally raw chunks.
+
+        Args:
+            query: Natural language search query.
+            node_limit: Max graph nodes (default 10).
+            article_limit: Max wiki articles (default 3). Set 0 to skip.
+            chunk_limit: Max raw chunks (default 0). Set >0 to include source text.
+            node_types: Filter to specific node types.
+            layer: Filter to a specific layer.
+            include_graph: Include graph nodes and edges (default True).
+            min_similarity: Minimum similarity threshold.
+        """
         body: dict[str, Any] = {"query": query}
-        if k is not None:
-            body["k"] = k
-        if depth is not None:
-            body["depth"] = depth
+        if node_limit is not None:
+            body["node_limit"] = node_limit
+        if article_limit is not None:
+            body["article_limit"] = article_limit
+        if chunk_limit is not None:
+            body["chunk_limit"] = chunk_limit
         if node_types:
             body["node_types"] = node_types
         if layer:
             body["layer"] = layer
-        if include_chunks is not None:
-            body["include_chunks"] = include_chunks
         if include_graph is not None:
             body["include_graph"] = include_graph
         if min_similarity is not None:
             body["min_similarity"] = min_similarity
         return self._request("POST", "/retrieve/context", body)
 
+    def backfill_node_sources(self) -> dict[str, Any]:
+        """Backfill node_source provenance from existing ExtractedFrom edges."""
+        return self._request("POST", "/backfill/node-sources", {})
+
     def list_jobs(self) -> list[dict[str, Any]]:
         return self._request("GET", "/jobs")
 
@@ -976,3 +1010,58 @@ class MindGraph:
     def clear_graph(self) -> dict[str, Any]:
         return self._request("POST", "/clear")
 
+    # ── Wiki ──────────────────────────────────────────────────────────────
+
+    def list_articles(
+        self,
+        *,
+        article_type: str | None = None,
+        covers_node_type: str | None = None,
+        search: str | None = None,
+        limit: int | None = None,
+        offset: int | None = None,
+    ) -> dict[str, Any]:
+        """List wiki articles with optional filters."""
+        params: dict[str, str] = {}
+        if article_type:
+            params["article_type"] = article_type
+        if covers_node_type:
+            params["covers_node_type"] = covers_node_type
+        if search:
+            params["search"] = search
+        if limit is not None:
+            params["limit"] = str(limit)
+        if offset is not None:
+            params["offset"] = str(offset)
+        qs = "&".join(f"{k}={v}" for k, v in params.items())
+        return self._request("GET", f"/wiki/articles?{qs}" if qs else "/wiki/articles")
+
+    def get_article(self, uid: str) -> dict[str, Any]:
+        """Get a single wiki article by UID."""
+        return self._request("GET", f"/wiki/article/{uid}")
+
+    def get_article_by_subject(self, subject_uid: str) -> dict[str, Any] | None:
+        """Find the article that covers or summarizes a given entity/document UID."""
+        try:
+            return self._request("GET", f"/wiki/article/by-subject/{subject_uid}")
+        except MindGraphError as e:
+            if e.status == 404:
+                return None
+            raise
+
+    def update_article(self, uid: str, content: str) -> dict[str, Any]:
+        """Update an article's markdown content (user editing)."""
+        return self._request("PATCH", f"/wiki/article/{uid}", {"content": content})
+
+    def compile_document(self, doc_uid: str) -> dict[str, Any]:
+        """Trigger wiki compilation for a specific document."""
+        return self._request("POST", f"/wiki/compile/{doc_uid}")
+
+    def compile_entity(self, entity_uid: str) -> dict[str, Any]:
+        """Trigger wiki compilation for a specific entity."""
+        return self._request("POST", f"/wiki/compile/entity/{entity_uid}")
+
+    def compile_all(self) -> dict[str, Any]:
+        """Backfill: compile articles for all documents and eligible entities."""
+        return self._request("POST", "/wiki/compile/all")
+

{mindgraph_sdk-0.2.1 → mindgraph_sdk-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mindgraph-sdk"
-version = "0.2.1"
+version = "0.3.0"
 description = "Python client for the MindGraph Cloud API"
 readme = "README.md"
 license = "MIT"