cognee 0.3.2__tar.gz → 0.3.3__tar.gz

{cognee-0.3.2 → cognee-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognee
-Version: 0.3.2
+Version: 0.3.3
 Summary: Cognee - is a library for enriching LLM context with a semantic layer for better understanding and reasoning.
 Project-URL: Homepage, https://www.cognee.ai
 Project-URL: Repository, https://github.com/topoteretes/cognee

{cognee-0.3.2 → cognee-0.3.3}/cognee/api/v1/notebooks/routers/get_notebooks_router.py

@@ -31,7 +31,8 @@ def get_notebooks_router():
 
     @router.get("")
     async def get_notebooks_endpoint(user: User = Depends(get_authenticated_user)):
-        return await get_notebooks(user.id)
+        async with get_async_session() as session:
+            return await get_notebooks(user.id, session)
 
     @router.post("")
     async def create_notebook_endpoint(

{cognee-0.3.2 → cognee-0.3.3}/cognee/infrastructure/databases/relational/sqlalchemy/SqlAlchemyAdapter.py

@@ -58,8 +58,8 @@ class SQLAlchemyAdapter:
         else:
             self.engine = create_async_engine(
                 connection_string,
-                pool_size=5,
-                max_overflow=10,
+                pool_size=20,
+                max_overflow=20,
                 pool_recycle=280,
                 pool_pre_ping=True,
                 pool_timeout=280,

{cognee-0.3.2 → cognee-0.3.3}/cognee/infrastructure/databases/vector/config.py

@@ -39,7 +39,7 @@ class VectorConfig(BaseSettings):
             values.vector_db_url = ensure_absolute_path(
                 values.vector_db_url,
             )
-        else:
+        elif not values.vector_db_url:
             # Default path
             databases_directory_path = os.path.join(base_config.system_root_directory, "databases")
             values.vector_db_url = os.path.join(databases_directory_path, "cognee.lancedb")

cognee-0.3.3/cognee/infrastructure/utils/run_async.py

@@ -0,0 +1,18 @@
+import asyncio
+from functools import partial
+import inspect
+
+
+async def run_async(func, *args, loop=None, executor=None, **kwargs):
+    if loop is None:
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = asyncio.get_event_loop()
+
+    if "loop" in inspect.signature(func).parameters:
+        pfunc = partial(func, *args, loop=loop, **kwargs)
+    else:
+        pfunc = partial(func, *args, **kwargs)
+
+    return await loop.run_in_executor(executor, pfunc)

{cognee-0.3.2 → cognee-0.3.3}/cognee/infrastructure/utils/run_sync.py

@@ -2,16 +2,17 @@ import asyncio
 import threading
 
 
-def run_sync(coro, timeout=None):
+def run_sync(coro, running_loop=None, timeout=None):
     result = None
     exception = None
 
     def runner():
-        nonlocal result, exception
+        nonlocal result, exception, running_loop
 
         try:
             try:
-                running_loop = asyncio.get_running_loop()
+                if not running_loop:
+                    running_loop = asyncio.get_running_loop()
 
                 result = asyncio.run_coroutine_threadsafe(coro, running_loop).result(timeout)
             except RuntimeError:

cognee-0.3.3/cognee/modules/notebooks/methods/create_tutorial_notebook.py

@@ -0,0 +1,92 @@
+
+from uuid import UUID, uuid4
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from ..models import NotebookCell
+from .create_notebook import create_notebook
+
+
+async def create_tutorial_notebook(user_id: UUID, session: AsyncSession):
+    await create_notebook(
+        user_id=user_id,
+        notebook_name="Welcome to cognee 🧠",
+        cells=[
+            NotebookCell(
+                id=uuid4(),
+                name="Welcome",
+                content="Cognee is your toolkit for turning text into a structured knowledge graph, optionally enhanced by ontologies, and then querying it with advanced retrieval techniques. This notebook will guide you through a simple example.",
+                type="markdown",
+            ),
+            NotebookCell(
+                id=uuid4(),
+                name="Example",
+                content="",
+                type="markdown",
+            ),
+        ],
+        deletable=False,
+        session=session,
+    )
+
+cell_content = [
+"""
+# Using Cognee with Python Development Data
+
+Unite authoritative Python practice (Guido van Rossum's own contributions!), normative guidance (Zen/PEP 8), and your lived context (rules + conversations) into one *AI memory* that produces answers that are relevant, explainable, and consistent.
+""",
+
+"""
+## What You'll Learn
+
+In this comprehensive tutorial, you'll discover how to transform scattered development data into an intelligent knowledge system that enhances your coding workflow. By the end, you'll have:
+- Connected disparate data sources (Guido's CPython contributions, mypy development, PEP discussions, your Python projects) into a unified AI memory graph
+- Built an memory layer that understands Python design philosophy, best practice coding patterns, and your preferences and experience
+- Learn how to use intelligent search capabilities that combine the diverse context
+- Integrated everything with your coding environment through MCP (Model Context Protocol)
+
+This tutorial demonstrates the power of **knowledge graphs** and **retrieval-augmented generation (RAG)** for software development, showing you how to build systems that learn from Python's creator and improve your own Python development.
+""",
+
+"""
+## Cognee and its core operations
+
+Before we dive in, let's understand the core Cognee operations we'll be working with:
+- `cognee.add()` - Ingests raw data (files, text, APIs) into the system
+- `cognee.cognify()` - Processes and structures data into a knowledge graph using AI
+- `cognee.search()` - Queries the knowledge graph with natural language or Cypher
+- `cognee.memify()` - Cognee's \"secret sauce\" that infers implicit connections and rules from your data
+""",
+
+"""
+## Data used in this tutorial
+
+Cognee can ingest many types of sources. In this tutorial, we use a small, concrete set of files that cover different perspectives:
+- `guido_contributions.json` — Authoritative exemplars. Real PRs and commits from Guido van Rossum (mypy, CPython). These show how Python's creator solved problems and provide concrete anchors for patterns.
+- `pep_style_guide.md` — Norms. Encodes community style and typing conventions (PEP 8 and related). Ensures that search results and inferred rules align with widely accepted standards.
+- `zen_principles.md` — Philosophy. The Zen of Python. Grounds design trade-offs (simplicity, explicitness, readability) beyond syntax or mechanics.
+- `my_developer_rules.md` — Local constraints. Your house rules, conventions, and project-specific requirements (scope, privacy, Spec.md). Keeps recommendations relevant to your actual workflow.
+- `copilot_conversations.json` — Personal history. Transcripts of real assistant conversations, including your questions, code snippets, and discussion topics. Captures "how you code" and connects it to "how Guido codes."
+""",
+
+"""
+# Preliminaries
+
+To strike the balanace between speed, cost, anc quality, we recommend using OpenAI's `4o-mini` model; make sure your `.env` file contains this line:
+`
+LLM_MODEL="gpt-4o-mini"
+`
+""",
+
+"""
+import cognee
+
+result = await cognee.add(
+    "file://data/guido_contributions.json",
+    node_set=["guido_data"]
+)
+
+await cognee.cognify(temporal_cognify=True)
+
+results = await cognee.search("Show me commits")
+"""
+]

{cognee-0.3.2 → cognee-0.3.3}/cognee/modules/notebooks/methods/get_notebook.py

@@ -1,6 +1,6 @@
 from uuid import UUID
 from typing import Optional
-from sqlalchemy import select
+from sqlalchemy import and_, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from cognee.infrastructure.databases.relational import with_async_session
@@ -15,7 +15,7 @@ async def get_notebook(
     session: AsyncSession,
 ) -> Optional[Notebook]:
     result = await session.execute(
-        select(Notebook).where(Notebook.owner_id == user_id and Notebook.id == notebook_id)
+        select(Notebook).where(and_(Notebook.owner_id == user_id, Notebook.id == notebook_id))
     )
 
     return result.scalar()

{cognee-0.3.2 → cognee-0.3.3}/cognee/modules/notebooks/methods/update_notebook.py

@@ -1,4 +1,3 @@
-from typing import Callable, AsyncContextManager
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from cognee.infrastructure.databases.relational import with_async_session

{cognee-0.3.2 → cognee-0.3.3}/cognee/modules/notebooks/operations/run_in_local_sandbox.py

@@ -5,16 +5,18 @@ import traceback
 
 def wrap_in_async_handler(user_code: str) -> str:
     return (
-        "from cognee.infrastructure.utils.run_sync import run_sync\n\n"
-        "async def __user_main__():\n"
+        "import asyncio\n"
+        + "asyncio.set_event_loop(running_loop)\n\n"
+        + "from cognee.infrastructure.utils.run_sync import run_sync\n\n"
+        + "async def __user_main__():\n"
         + "\n".join("    " + line for line in user_code.strip().split("\n"))
         + "\n"
-        "    globals().update(locals())\n\n"
-        "run_sync(__user_main__())\n"
+        + "    globals().update(locals())\n\n"
+        + "run_sync(__user_main__(), running_loop)\n"
     )
 
 
-def run_in_local_sandbox(code, environment=None):
+def run_in_local_sandbox(code, environment=None, loop=None):
     environment = environment or {}
     code = wrap_in_async_handler(code.replace("\xa0", "\n"))
 
@@ -31,6 +33,7 @@ def run_in_local_sandbox(code, environment=None):
         printOutput.append(output)
 
     environment["print"] = customPrintFunction
+    environment["running_loop"] = loop
 
     try:
         exec(code, environment)

{cognee-0.3.2 → cognee-0.3.3}/cognee/modules/retrieval/graph_completion_context_extension_retriever.py

@@ -48,7 +48,7 @@ class GraphCompletionContextExtensionRetriever(GraphCompletionRetriever):
         query: str,
         context: Optional[List[Edge]] = None,
         context_extension_rounds=4,
-    ) -> str:
+    ) -> List[str]:
         """
         Extends the context for a given query by retrieving related triplets and generating new
         completions based on them.

{cognee-0.3.2 → cognee-0.3.3}/cognee/modules/retrieval/graph_completion_cot_retriever.py

@@ -58,7 +58,7 @@ class GraphCompletionCotRetriever(GraphCompletionRetriever):
         query: str,
         context: Optional[List[Edge]] = None,
         max_iter=4,
-    ) -> str:
+    ) -> List[str]:
         """
         Generate completion responses based on a user query and contextual information.
 

{cognee-0.3.2 → cognee-0.3.3}/cognee/modules/retrieval/graph_completion_retriever.py

@@ -135,7 +135,7 @@ class GraphCompletionRetriever(BaseGraphRetriever):
         self,
         query: str,
         context: Optional[List[Edge]] = None,
-    ) -> Any:
+    ) -> List[str]:
         """
         Generates a completion using graph connections context based on a query.
 

{cognee-0.3.2 → cognee-0.3.3}/cognee/modules/retrieval/temporal_retriever.py

@@ -136,7 +136,7 @@ class TemporalRetriever(GraphCompletionRetriever):
 
         return self.descriptions_to_string(top_k_events)
 
-    async def get_completion(self, query: str, context: Optional[str] = None) -> str:
+    async def get_completion(self, query: str, context: Optional[str] = None) -> List[str]:
         """Generates a response using the query and optional context."""
         if not context:
             context = await self.get_context(query=query)

{cognee-0.3.2 → cognee-0.3.3}/cognee/modules/retrieval/user_qa_feedback.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional, List
+from typing import Optional, List
 
 from uuid import NAMESPACE_OID, uuid5, UUID
 from cognee.infrastructure.databases.graph import get_graph_engine

{cognee-0.3.2 → cognee-0.3.3}/cognee/modules/search/utils/prepare_search_result.py

@@ -6,7 +6,7 @@ from cognee.modules.search.utils.transform_context_to_graph import transform_con
 
 
 async def prepare_search_result(search_result):
-    result, context, datasets = search_result
+    results, context, datasets = search_result
 
     graphs = None
     result_graph = None
@@ -30,11 +30,11 @@ async def prepare_search_result(search_result):
             "*": "\n".join(cast(List[str], context)),
         }
 
-    if isinstance(result, List) and len(result) > 0 and isinstance(result[0], Edge):
-        result_graph = transform_context_to_graph(result)
+    if isinstance(results, List) and len(results) > 0 and isinstance(results[0], Edge):
+        result_graph = transform_context_to_graph(results)
 
     return {
-        "result": result_graph or result,
+        "result": result_graph or results[0] if len(results) == 1 else results,
         "graphs": graphs,
         "context": context_texts,
         "datasets": datasets,

{cognee-0.3.2 → cognee-0.3.3}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "cognee"
 
-version = "0.3.2"
+version = "0.3.3"
 description = "Cognee - is a library for enriching LLM context with a semantic layer for better understanding and reasoning."
 authors = [
     { name = "Vasilije Markovic" },
@@ -147,7 +147,7 @@ Homepage = "https://www.cognee.ai"
 Repository = "https://github.com/topoteretes/cognee"
 
 [project.scripts]
-cognee = "cognee.cli._cognee:main"
+cognee-cli = "cognee.cli._cognee:main"
 
 [build-system]
 requires = ["hatchling"]

{cognee-0.3.2 → cognee-0.3.3}/uv.lock

@@ -807,7 +807,7 @@ wheels = [
 
 [[package]]
 name = "cognee"
-version = "0.3.2"
+version = "0.3.3"
 source = { editable = "." }
 dependencies = [
     { name = "aiofiles" },

cognee-0.3.2/cognee/api/v1/save/save.py

@@ -1,335 +0,0 @@
-import os
-import asyncio
-import json
-from typing import Optional, Union, List, Dict
-from uuid import UUID
-
-from pydantic import BaseModel
-
-from cognee.base_config import get_base_config
-from cognee.modules.users.models import User
-from cognee.modules.users.methods import get_default_user
-from cognee.modules.data.methods import get_authorized_existing_datasets, get_dataset_data
-from cognee.infrastructure.files.utils.get_data_file_path import get_data_file_path
-from cognee.infrastructure.llm.LLMGateway import LLMGateway
-from cognee.shared.logging_utils import get_logger
-from cognee.api.v1.search import search
-from cognee.modules.search.types import SearchType
-
-
-logger = get_logger("save")
-
-
-class QuestionsModel(BaseModel):
-    questions: List[str]
-
-
-def _sanitize_filename(name: str) -> str:
-    safe = "".join(c if c.isalnum() or c in ("-", "_", ".", " ") else "_" for c in name)
-    return safe.strip().replace(" ", "_")
-
-
-def _dataset_dir_name(dataset) -> str:
-    # Prefer readable dataset name when available, fallback to id
-    if getattr(dataset, "name", None):
-        return _sanitize_filename(str(dataset.name))
-    return str(dataset.id)
-
-
-def _file_markdown_name(data_item, used_names: set[str]) -> str:
-    # Use original file name if present, else data.name
-    name = getattr(data_item, "name", None) or "file"
-    base = _sanitize_filename(str(name))
-    filename = f"{base}.md"
-    if filename in used_names:
-        short_id = str(getattr(data_item, "id", ""))[:8]
-        filename = f"{base}__{short_id}.md"
-    used_names.add(filename)
-    return filename
-
-
-def _ascii_path_tree(path_str: str) -> str:
-    if not path_str:
-        return "(no path)"
-
-    # Normalize special schemes but keep segments readable
-    try:
-        normalized = get_data_file_path(path_str)
-    except Exception:
-        normalized = path_str
-
-    # Keep the path compact – show last 5 segments
-    parts = [p for p in normalized.replace("\\", "/").split("/") if p]
-    if len(parts) > 6:
-        display = ["…"] + parts[-5:]
-    else:
-        display = parts
-
-    # Render a single-branch tree
-    lines = []
-    for idx, seg in enumerate(display):
-        prefix = "└── " if idx == 0 else ("    " * idx + "└── ")
-        lines.append(f"{prefix}{seg}")
-    return "\n".join(lines)
-
-
-async def _get_summary_via_summaries(query_text: str, dataset_id: UUID, top_k: int) -> str:
-    try:
-        results = await search(
-            query_text=query_text,
-            query_type=SearchType.SUMMARIES,
-            dataset_ids=[dataset_id],
-            top_k=top_k,
-        )
-        if not results:
-            return ""
-        texts: List[str] = []
-        for r in results[:top_k]:
-            texts.append(str(r))
-        return "\n\n".join(texts)
-    except Exception as e:
-        logger.error(
-            "SUMMARIES search failed for '%s' in dataset %s: %s",
-            query_text,
-            str(dataset_id),
-            str(e),
-        )
-        return ""
-
-
-async def _generate_questions(file_name: str, summary_text: str) -> List[str]:
-    prompt = (
-        "You are an expert analyst. Given a file and its summary, propose 10 diverse, high-signal "
-        "questions to further explore the file's content, implications, relationships, and gaps. "
-        "Avoid duplicates; vary depth and angle (overview, details, cross-references, temporal, quality).\n\n"
-        f"File: {file_name}\n\nSummary:\n{summary_text[:4000]}"
-    )
-
-    model = await LLMGateway.acreate_structured_output(
-        text_input=prompt,
-        system_prompt="Return strictly a JSON with key 'questions' and value as an array of 10 concise strings.",
-        response_model=QuestionsModel,
-    )
-
-    # model can be either pydantic model or dict-like, normalize
-    try:
-        questions = list(getattr(model, "questions", []))
-    except Exception:
-        questions = []
-
-    # Fallback if the tool returned a dict-like
-    if not questions and isinstance(model, dict):
-        questions = list(model.get("questions", []) or [])
-
-    # Enforce 10 max
-    return questions[:10]
-
-
-async def _run_searches_for_question(
-    question: str, dataset_id: UUID, search_types: List[SearchType], top_k: int
-) -> Dict[str, Union[str, List[dict], List[str]]]:
-    async def run_one(st: SearchType):
-        try:
-            result = await search(
-                query_text=question,
-                query_type=st,
-                dataset_ids=[dataset_id],
-                top_k=top_k,
-            )
-            return st.value, result
-        except Exception as e:
-            logger.error("Search failed for type %s: %s", st.value, str(e))
-            return st.value, [f"Error: {str(e)}"]
-
-    pairs = await asyncio.gather(*[run_one(st) for st in search_types])
-    return {k: v for k, v in pairs}
-
-
-def _format_results_md(results: Dict[str, Union[str, List[dict], List[str]]]) -> str:
-    lines: List[str] = []
-    for st, payload in results.items():
-        lines.append(f"#### {st}")
-        if isinstance(payload, list):
-            # Printed as bullet items; stringify dicts
-            for item in payload[:5]:
-                if isinstance(item, dict):
-                    # compact representation
-                    snippet = json.dumps(item, ensure_ascii=False)[:800]
-                    lines.append(f"- {snippet}")
-                else:
-                    text = str(item)
-                    lines.append(f"- {text[:800]}")
-        else:
-            lines.append(str(payload))
-        lines.append("")
-    return "\n".join(lines)
-
-
-async def save(
-    datasets: Optional[Union[List[str], List[UUID]]] = None,
-    export_root_directory: Optional[str] = None,
-    user: Optional[User] = None,
-    # Configurable knobs
-    max_questions: int = 10,
-    search_types: Optional[List[Union[str, SearchType]]] = None,
-    top_k: int = 5,
-    include_summary: bool = True,
-    include_ascii_tree: bool = True,
-    concurrency: int = 4,
-    timeout: Optional[float] = None,
-) -> Dict[str, str]:
-    """
-    Export per-dataset markdown summaries and search insights for each ingested file.
-
-    For every dataset the user can read:
-    - Create a folder under export_root_directory (or data_root_directory/exports)
-    - For each data item (file), create a .md containing:
-      - Summary of the file (from existing TextSummary nodes)
-      - A small ASCII path tree showing its folder position
-      - Up to N LLM-generated question ideas (configurable)
-      - Results of configured Cognee searches per question
-    Also creates an index.md per dataset with links to files and an optional dataset summary.
-
-    Returns a mapping of dataset_id -> export_directory path.
-    """
-    base_config = get_base_config()
-    export_root = export_root_directory or os.path.join(
-        base_config.data_root_directory, "memory_export"
-    )
-    os.makedirs(export_root, exist_ok=True)
-
-    if user is None:
-        user = await get_default_user()
-
-    datasets_list = await get_authorized_existing_datasets(datasets, "read", user)
-    results: Dict[str, str] = {}
-
-    for dataset in datasets_list:
-        ds_dir = os.path.join(export_root, _dataset_dir_name(dataset))
-        os.makedirs(ds_dir, exist_ok=True)
-        results[str(dataset.id)] = ds_dir
-
-        data_items = await get_dataset_data(dataset.id)
-
-        # Normalize search types
-        if not search_types:
-            effective_search_types = [
-                SearchType.GRAPH_COMPLETION,
-                SearchType.INSIGHTS,
-                SearchType.CHUNKS,
-            ]
-        else:
-            effective_search_types = []
-            for st in search_types:
-                if isinstance(st, SearchType):
-                    effective_search_types.append(st)
-                else:
-                    try:
-                        effective_search_types.append(SearchType[str(st)])
-                    except Exception:
-                        logger.warning("Unknown search type '%s', skipping", str(st))
-
-        sem = asyncio.Semaphore(max(1, int(concurrency)))
-        used_names: set[str] = set()
-        index_entries: List[tuple[str, str]] = []
-
-        async def process_one(data_item):
-            async with sem:
-                file_label = getattr(data_item, "name", str(data_item.id))
-                original_path = getattr(data_item, "original_data_location", None)
-
-                ascii_tree = (
-                    _ascii_path_tree(original_path or file_label) if include_ascii_tree else ""
-                )
-
-                summary_text = ""
-                if include_summary:
-                    # Use SUMMARIES search scoped to dataset to derive file summary
-                    file_query = getattr(data_item, "name", str(data_item.id)) or "file"
-                    summary_text = await _get_summary_via_summaries(file_query, dataset.id, top_k)
-                    if not summary_text:
-                        summary_text = "Summary not available."
-
-                if max_questions == 0:
-                    questions = []
-                else:
-                    questions = await _generate_questions(file_label, summary_text)
-                    if max_questions is not None and max_questions >= 0:
-                        questions = questions[:max_questions]
-
-                async def searches_for_question(q: str):
-                    return await _run_searches_for_question(
-                        q, dataset.id, effective_search_types, top_k
-                    )
-
-                # Run per-question searches concurrently
-                per_q_results = await asyncio.gather(*[searches_for_question(q) for q in questions])
-
-                # Build markdown content
-                md_lines = [f"# {file_label}", ""]
-                if include_ascii_tree:
-                    md_lines.extend(["## Location", "", "```", ascii_tree, "```", ""])
-                if include_summary:
-                    md_lines.extend(["## Summary", "", summary_text, ""])
-
-                md_lines.append("## Question ideas")
-                for idx, q in enumerate(questions, start=1):
-                    md_lines.append(f"- {idx}. {q}")
-                md_lines.append("")
-
-                md_lines.append("## Searches")
-                md_lines.append("")
-                for q, per_type in zip(questions, per_q_results):
-                    md_lines.append(f"### Q: {q}")
-                    md_lines.append(_format_results_md(per_type))
-                    md_lines.append("")
-
-                # Write to file (collision-safe)
-                md_filename = _file_markdown_name(data_item, used_names)
-                export_path = os.path.join(ds_dir, md_filename)
-                tmp_path = export_path + ".tmp"
-                with open(tmp_path, "w", encoding="utf-8") as f:
-                    f.write("\n".join(md_lines))
-                os.replace(tmp_path, export_path)
-
-                index_entries.append((file_label, md_filename))
-
-        tasks = [asyncio.create_task(process_one(item)) for item in data_items]
-
-        if timeout and timeout > 0:
-            try:
-                await asyncio.wait_for(asyncio.gather(*tasks, return_exceptions=True), timeout)
-            except asyncio.TimeoutError:
-                logger.error("Save timed out for dataset %s", str(dataset.id))
-        else:
-            await asyncio.gather(*tasks, return_exceptions=True)
-
-        # Build dataset index.md with TOC and optional dataset summary via SUMMARIES
-        try:
-            index_lines = [f"# Dataset: {_dataset_dir_name(dataset)}", "", "## Files", ""]
-            for display, fname in sorted(index_entries, key=lambda x: x[0].lower()):
-                index_lines.append(f"- [{display}]({fname})")
-
-            # Dataset summary section
-            try:
-                summaries = await search(
-                    query_text="dataset overview",
-                    query_type=SearchType.SUMMARIES,
-                    dataset_ids=[dataset.id],
-                    top_k=top_k,
-                )
-            except Exception as e:
-                logger.error("Dataset summary search failed: %s", str(e))
-                summaries = []
-
-            if summaries:
-                index_lines.extend(["", "## Dataset summary (top summaries)", ""])
-                for s in summaries[:top_k]:
-                    index_lines.append(f"- {str(s)[:800]}")
-
-            with open(os.path.join(ds_dir, "index.md"), "w", encoding="utf-8") as f:
-                f.write("\n".join(index_lines))
-        except Exception as e:
-            logger.error("Failed to write dataset index for %s: %s", str(dataset.id), str(e))
-
-    return results