cognee 0.2.3.dev1__py3-none-any.whl → 0.3.0.dev0__py3-none-any.whl

cognee/cli/commands/delete_command.py

@@ -0,0 +1,80 @@
+import argparse
+import asyncio
+from typing import Optional
+
+from cognee.cli.reference import SupportsCliCommand
+from cognee.cli import DEFAULT_DOCS_URL
+import cognee.cli.echo as fmt
+from cognee.cli.exceptions import CliCommandException, CliCommandInnerException
+
+
+class DeleteCommand(SupportsCliCommand):
+    command_string = "delete"
+    help_string = "Delete data from cognee knowledge base"
+    docs_url = DEFAULT_DOCS_URL
+    description = """
+The `cognee delete` command removes data from your knowledge base.
+
+You can delete:
+- Specific datasets by name
+- All data (with confirmation)
+- Data for specific users
+
+Be careful with deletion operations as they are irreversible.
+    """
+
+    def configure_parser(self, parser: argparse.ArgumentParser) -> None:
+        parser.add_argument("--dataset-name", "-d", help="Specific dataset to delete")
+        parser.add_argument("--user-id", "-u", help="User ID to delete data for")
+        parser.add_argument(
+            "--all", action="store_true", help="Delete all data (requires confirmation)"
+        )
+        parser.add_argument("--force", "-f", action="store_true", help="Skip confirmation prompts")
+
+    def execute(self, args: argparse.Namespace) -> None:
+        try:
+            # Import cognee here to avoid circular imports
+            import cognee
+
+            # Validate arguments
+            if not any([args.dataset_name, args.user_id, args.all]):
+                fmt.error("Please specify what to delete: --dataset-name, --user-id, or --all")
+                return
+
+            # Build confirmation message
+            if args.all:
+                confirm_msg = "Delete ALL data from cognee?"
+                operation = "all data"
+            elif args.dataset_name:
+                confirm_msg = f"Delete dataset '{args.dataset_name}'?"
+                operation = f"dataset '{args.dataset_name}'"
+            elif args.user_id:
+                confirm_msg = f"Delete all data for user '{args.user_id}'?"
+                operation = f"data for user '{args.user_id}'"
+
+            # Confirm deletion unless forced
+            if not args.force:
+                fmt.warning("This operation is irreversible!")
+                if not fmt.confirm(confirm_msg):
+                    fmt.echo("Deletion cancelled.")
+                    return
+
+            fmt.echo(f"Deleting {operation}...")
+
+            # Run the async delete function
+            async def run_delete():
+                try:
+                    if args.all:
+                        await cognee.delete(dataset_name=None, user_id=args.user_id)
+                    else:
+                        await cognee.delete(dataset_name=args.dataset_name, user_id=args.user_id)
+                except Exception as e:
+                    raise CliCommandInnerException(f"Failed to delete: {str(e)}")
+
+            asyncio.run(run_delete())
+            fmt.success(f"Successfully deleted {operation}")
+
+        except Exception as e:
+            if isinstance(e, CliCommandInnerException):
+                raise CliCommandException(str(e), error_code=1)
+            raise CliCommandException(f"Error deleting data: {str(e)}", error_code=1)

cognee/cli/commands/search_command.py

@@ -0,0 +1,149 @@
+import argparse
+import asyncio
+import json
+from typing import Optional
+
+from cognee.cli.reference import SupportsCliCommand
+from cognee.cli import DEFAULT_DOCS_URL
+from cognee.cli.config import SEARCH_TYPE_CHOICES, OUTPUT_FORMAT_CHOICES
+import cognee.cli.echo as fmt
+from cognee.cli.exceptions import CliCommandException, CliCommandInnerException
+
+
+class SearchCommand(SupportsCliCommand):
+    command_string = "search"
+    help_string = "Search and query the knowledge graph for insights, information, and connections"
+    docs_url = DEFAULT_DOCS_URL
+    description = """
+Search and query the knowledge graph for insights, information, and connections.
+
+This is the final step in the Cognee workflow that retrieves information from the
+processed knowledge graph. It supports multiple search modes optimized for different
+use cases - from simple fact retrieval to complex reasoning and code analysis.
+
+Search Types & Use Cases:
+
+**GRAPH_COMPLETION** (Default - Recommended):
+    Natural language Q&A using full graph context and LLM reasoning.
+    Best for: Complex questions, analysis, summaries, insights.
+
+**RAG_COMPLETION**:
+    Traditional RAG using document chunks without graph structure.
+    Best for: Direct document retrieval, specific fact-finding.
+
+**INSIGHTS**:
+    Structured entity relationships and semantic connections.
+    Best for: Understanding concept relationships, knowledge mapping.
+
+**CHUNKS**:
+    Raw text segments that match the query semantically.
+    Best for: Finding specific passages, citations, exact content.
+
+**SUMMARIES**:
+    Pre-generated hierarchical summaries of content.
+    Best for: Quick overviews, document abstracts, topic summaries.
+
+**CODE**:
+    Code-specific search with syntax and semantic understanding.
+    Best for: Finding functions, classes, implementation patterns.
+    """
+
+    def configure_parser(self, parser: argparse.ArgumentParser) -> None:
+        parser.add_argument("query_text", help="Your question or search query in natural language")
+        parser.add_argument(
+            "--query-type",
+            "-t",
+            choices=SEARCH_TYPE_CHOICES,
+            default="GRAPH_COMPLETION",
+            help="Search mode (default: GRAPH_COMPLETION for conversational AI responses)",
+        )
+        parser.add_argument(
+            "--datasets",
+            "-d",
+            nargs="*",
+            help="Dataset name(s) to search within. Searches all accessible datasets if not specified",
+        )
+        parser.add_argument(
+            "--top-k",
+            "-k",
+            type=int,
+            default=10,
+            help="Maximum number of results to return (default: 10, max: 100)",
+        )
+        parser.add_argument(
+            "--system-prompt",
+            help="Custom system prompt file for LLM-based search types (default: answer_simple_question.txt)",
+        )
+        parser.add_argument(
+            "--output-format",
+            "-f",
+            choices=OUTPUT_FORMAT_CHOICES,
+            default="pretty",
+            help="Output format (default: pretty)",
+        )
+
+    def execute(self, args: argparse.Namespace) -> None:
+        try:
+            # Import cognee here to avoid circular imports
+            import cognee
+            from cognee.modules.search.types import SearchType
+
+            # Convert string to SearchType enum
+            query_type = SearchType[args.query_type]
+
+            datasets_msg = (
+                f" in datasets {args.datasets}" if args.datasets else " across all datasets"
+            )
+            fmt.echo(f"Searching for: '{args.query_text}' (type: {args.query_type}){datasets_msg}")
+
+            # Run the async search function
+            async def run_search():
+                try:
+                    results = await cognee.search(
+                        query_text=args.query_text,
+                        query_type=query_type,
+                        datasets=args.datasets,
+                        system_prompt_path=args.system_prompt or "answer_simple_question.txt",
+                        top_k=args.top_k,
+                    )
+                    return results
+                except Exception as e:
+                    raise CliCommandInnerException(f"Failed to search: {str(e)}")
+
+            results = asyncio.run(run_search())
+
+            # Format and display results
+            if args.output_format == "json":
+                fmt.echo(json.dumps(results, indent=2, default=str))
+            elif args.output_format == "simple":
+                for i, result in enumerate(results, 1):
+                    fmt.echo(f"{i}. {result}")
+            else:  # pretty format
+                if not results:
+                    fmt.warning("No results found for your query.")
+                    return
+
+                fmt.echo(f"\nFound {len(results)} result(s) using {args.query_type}:")
+                fmt.echo("=" * 60)
+
+                if args.query_type in ["GRAPH_COMPLETION", "RAG_COMPLETION"]:
+                    # These return conversational responses
+                    for i, result in enumerate(results, 1):
+                        fmt.echo(f"{fmt.bold('Response:')} {result}")
+                        if i < len(results):
+                            fmt.echo("-" * 40)
+                elif args.query_type == "CHUNKS":
+                    # These return text chunks
+                    for i, result in enumerate(results, 1):
+                        fmt.echo(f"{fmt.bold(f'Chunk {i}:')} {result}")
+                        fmt.echo()
+                else:
+                    # Generic formatting for other types
+                    for i, result in enumerate(results, 1):
+                        fmt.echo(f"{fmt.bold(f'Result {i}:')} {result}")
+                        fmt.echo()
+
+        except Exception as e:
+            if isinstance(e, CliCommandInnerException):
+                raise CliCommandException(str(e), error_code=1)
+            raise CliCommandException(f"Error searching: {str(e)}", error_code=1)

cognee/cli/config.py

@@ -0,0 +1,33 @@
+"""
+CLI configuration and constants to avoid hardcoded values
+"""
+
+# CLI Constants
+CLI_DESCRIPTION = "Cognee CLI - Manage your knowledge graphs and cognitive processing pipelines."
+DEFAULT_DOCS_URL = "https://docs.cognee.ai"
+
+# Command descriptions - these should match the actual command implementations
+COMMAND_DESCRIPTIONS = {
+    "add": "Add data to Cognee for knowledge graph processing",
+    "search": "Search and query the knowledge graph for insights, information, and connections",
+    "cognify": "Transform ingested data into a structured knowledge graph",
+    "delete": "Delete data from cognee knowledge base",
+    "config": "Manage cognee configuration settings",
+}
+
+# Search type choices
+SEARCH_TYPE_CHOICES = [
+    "GRAPH_COMPLETION",
+    "RAG_COMPLETION",
+    "INSIGHTS",
+    "CHUNKS",
+    "SUMMARIES",
+    "CODE",
+    "CYPHER",
+]
+
+# Chunker choices
+CHUNKER_CHOICES = ["TextChunker", "LangchainChunker"]
+
+# Output format choices
+OUTPUT_FORMAT_CHOICES = ["json", "pretty", "simple"]

cognee/cli/debug.py

@@ -0,0 +1,21 @@
+"""Provides a global debug setting for the CLI - following dlt patterns"""
+
+_DEBUG_FLAG = False
+
+
+def enable_debug() -> None:
+    """Enable debug mode for CLI"""
+    global _DEBUG_FLAG
+    _DEBUG_FLAG = True
+
+
+def disable_debug() -> None:
+    """Disable debug mode for CLI"""
+    global _DEBUG_FLAG
+    _DEBUG_FLAG = False
+
+
+def is_debug_enabled() -> bool:
+    """Check if debug mode is enabled"""
+    global _DEBUG_FLAG
+    return _DEBUG_FLAG

cognee/cli/echo.py

@@ -0,0 +1,45 @@
+"""CLI output formatting utilities"""
+
+import sys
+import click
+from typing import Any
+
+
+def echo(message: str = "", color: str = None, err: bool = False) -> None:
+    """Echo a message to stdout or stderr with optional color"""
+    click.secho(message, fg=color, err=err)
+
+
+def note(message: str) -> None:
+    """Print a note in blue"""
+    echo(f"Note: {message}", color="blue")
+
+
+def warning(message: str) -> None:
+    """Print a warning in yellow"""
+    echo(f"Warning: {message}", color="yellow")
+
+
+def error(message: str) -> None:
+    """Print an error in red"""
+    echo(f"Error: {message}", color="red", err=True)
+
+
+def success(message: str) -> None:
+    """Print a success message in green"""
+    echo(f"Success: {message}", color="green")
+
+
+def bold(text: str) -> str:
+    """Make text bold"""
+    return click.style(text, bold=True)
+
+
+def confirm(message: str, default: bool = False) -> bool:
+    """Ask for user confirmation"""
+    return click.confirm(message, default=default)
+
+
+def prompt(message: str, default: Any = None) -> str:
+    """Prompt user for input"""
+    return click.prompt(message, default=default)

cognee/cli/exceptions.py

@@ -0,0 +1,23 @@
+from typing import Optional
+
+
+class CliCommandException(Exception):
+    """Exception raised by CLI commands with additional context"""
+
+    def __init__(
+        self,
+        message: str,
+        error_code: int = -1,
+        docs_url: Optional[str] = None,
+        raiseable_exception: Optional[Exception] = None,
+    ) -> None:
+        super().__init__(message)
+        self.error_code = error_code
+        self.docs_url = docs_url
+        self.raiseable_exception = raiseable_exception
+
+
+class CliCommandInnerException(Exception):
+    """Inner exception for wrapping other exceptions in CLI context"""
+
+    pass

cognee/cli/minimal_cli.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+"""
+Minimal CLI entry point for cognee that avoids early initialization
+"""
+
+import sys
+import os
+from typing import Any, Sequence
+
+# CRITICAL: Prevent verbose logging initialization for CLI-only usage
+# This must be set before any cognee imports to be effective
+os.environ["COGNEE_MINIMAL_LOGGING"] = "true"
+os.environ["COGNEE_CLI_MODE"] = "true"
+
+
+def get_version() -> str:
+    """Get cognee version without importing the main package"""
+    try:
+        # Try to get version from pyproject.toml first (for development)
+        from pathlib import Path
+
+        pyproject_path = Path(__file__).parent.parent.parent / "pyproject.toml"
+        if pyproject_path.exists():
+            with open(pyproject_path, encoding="utf-8") as f:
+                for line in f:
+                    if line.startswith("version"):
+                        version = line.split("=")[1].strip("'\"\n ")
+                        return f"{version}-local"
+
+        # Fallback to installed package version
+        import importlib.metadata
+
+        return importlib.metadata.version("cognee")
+    except Exception:
+        return "unknown"
+
+
+def get_command_info() -> dict:
+    """Get command information without importing cognee"""
+    return {
+        "add": "Add data to Cognee for knowledge graph processing",
+        "search": "Search and query the knowledge graph for insights, information, and connections",
+        "cognify": "Transform ingested data into a structured knowledge graph",
+        "delete": "Delete data from cognee knowledge base",
+        "config": "Manage cognee configuration settings",
+    }
+
+
+def print_help() -> None:
+    """Print help message with dynamic command descriptions"""
+    commands = get_command_info()
+    command_list = "\n".join(f"    {cmd:<12} {desc}" for cmd, desc in commands.items())
+
+    print(f"""
+usage: cognee [-h] [--version] [--debug] {{{"|".join(commands.keys())}}} ...
+
+Cognee CLI - Manage your knowledge graphs and cognitive processing pipelines.
+
+options:
+  -h, --help            show this help message and exit
+  --version             show program's version number and exit
+  --debug               Enable debug mode to show full stack traces on exceptions
+
+Available commands:
+  {{{",".join(commands.keys())}}}
+{command_list}
+
+For more information on each command, use: cognee <command> --help
+""")
+
+
+def main() -> int:
+    """Minimal CLI main function"""
+    # Handle help and version without any imports - purely static
+    if len(sys.argv) == 1 or (len(sys.argv) == 2 and sys.argv[1] in ["-h", "--help"]):
+        print_help()
+        return 0
+
+    if len(sys.argv) == 2 and sys.argv[1] == "--version":
+        print(f"cognee {get_version()}")
+        return 0
+
+    # For actual commands, import the full CLI with minimal logging
+    try:
+        from cognee.cli._cognee import main as full_main
+
+        return full_main()
+    except Exception as e:
+        if "--debug" in sys.argv:
+            raise
+        print(f"Error: {e}")
+        print("Use --debug for full stack trace")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

cognee/cli/reference.py

@@ -0,0 +1,26 @@
+from abc import abstractmethod
+from typing import Protocol, Optional
+import argparse
+
+
+class SupportsCliCommand(Protocol):
+    """Protocol for defining one cognee cli command"""
+
+    command_string: str
+    """name of the command"""
+    help_string: str
+    """the help string for argparse"""
+    description: Optional[str]
+    """the more detailed description for argparse, may include markdown for the docs"""
+    docs_url: Optional[str]
+    """the default docs url to be printed in case of an exception"""
+
+    @abstractmethod
+    def configure_parser(self, parser: argparse.ArgumentParser) -> None:
+        """Configures the parser for the given argument"""
+        ...
+
+    @abstractmethod
+    def execute(self, args: argparse.Namespace) -> None:
+        """Executes the command with the given arguments"""
+        ...

cognee/cli/suppress_logging.py

@@ -0,0 +1,12 @@
+"""
+Module to suppress verbose logging before any cognee imports.
+This must be imported before any other cognee modules.
+"""
+
+import os
+
+# Set CLI mode to suppress verbose logging
+os.environ["COGNEE_CLI_MODE"] = "true"
+
+# Also set log level to ERROR for extra safety
+os.environ["LOG_LEVEL"] = "ERROR"

cognee/eval_framework/corpus_builder/corpus_builder_executor.py

@@ -5,7 +5,7 @@ from typing import Optional, Tuple, List, Dict, Union, Any, Callable, Awaitable
 from cognee.eval_framework.benchmark_adapters.benchmark_adapters import BenchmarkAdapter
 from cognee.modules.chunking.TextChunker import TextChunker
 from cognee.modules.pipelines.tasks.task import Task
-from cognee.modules.pipelines import cognee_pipeline
+from cognee.modules.pipelines import run_pipeline
 
 logger = get_logger(level=ERROR)
 
@@ -61,7 +61,7 @@ class CorpusBuilderExecutor:
         await cognee.add(self.raw_corpus)
 
         tasks = await self.task_getter(chunk_size=chunk_size, chunker=chunker)
-        pipeline_run = cognee_pipeline(tasks=tasks)
+        pipeline_run = run_pipeline(tasks=tasks)
 
         async for run_info in pipeline_run:
             print(run_info)

cognee/eval_framework/eval_config.py

@@ -25,7 +25,7 @@ class EvalConfig(BaseSettings):
         "EM",
         "f1",
     ]  # Use only 'correctness' for DirectLLM
-    deepeval_model: str = "gpt-4o-mini"
+    deepeval_model: str = "gpt-5-mini"
 
     # Metrics params
     calculate_metrics: bool = True

cognee/infrastructure/databases/graph/config.py

@@ -6,6 +6,7 @@ from pydantic_settings import BaseSettings, SettingsConfigDict
 import pydantic
 from pydantic import Field
 from cognee.base_config import get_base_config
+from cognee.root_dir import ensure_absolute_path
 from cognee.shared.data_models import KnowledgeGraph
 
 
@@ -51,15 +52,20 @@ class GraphConfig(BaseSettings):
     @pydantic.model_validator(mode="after")
     def fill_derived(cls, values):
         provider = values.graph_database_provider.lower()
+        base_config = get_base_config()
 
         # Set default filename if no filename is provided
         if not values.graph_filename:
             values.graph_filename = f"cognee_graph_{provider}"
 
-        # Set file path based on graph database provider if no file path is provided
-        if not values.graph_file_path:
-            base_config = get_base_config()
-
+        # Handle graph file path
+        if values.graph_file_path:
+            # Check if absolute path is provided
+            values.graph_file_path = ensure_absolute_path(
+                os.path.join(values.graph_file_path, values.graph_filename)
+            )
+        else:
+            # Default path
             databases_directory_path = os.path.join(base_config.system_root_directory, "databases")
             values.graph_file_path = os.path.join(databases_directory_path, values.graph_filename)
 

cognee/infrastructure/databases/graph/get_graph_engine.py

@@ -21,10 +21,6 @@ async def get_graph_engine() -> GraphDBInterface:
     if hasattr(graph_client, "initialize"):
         await graph_client.initialize()
 
-    # Handle loading of graph for NetworkX
-    if config["graph_database_provider"].lower() == "networkx" and graph_client.graph is None:
-        await graph_client.load_graph_from_file()
-
     return graph_client
 
 
@@ -181,8 +177,7 @@ def create_graph_engine(
             graph_id=graph_identifier,
         )
 
-    from .networkx.adapter import NetworkXAdapter
-
-    graph_client = NetworkXAdapter(filename=graph_file_path)
-
-    return graph_client
+    raise EnvironmentError(
+        f"Unsupported graph database provider: {graph_database_provider}. "
+        f"Supported providers are: {', '.join(list(supported_databases.keys()) + ['neo4j', 'falkordb', 'kuzu', 'kuzu-remote', 'memgraph', 'neptune', 'neptune_analytics'])}"
+    )