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

cognee/cli/commands/config_command.py

@@ -0,0 +1,225 @@
+import argparse
+import json
+from typing import Optional, Any
+
+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 ConfigCommand(SupportsCliCommand):
+    command_string = "config"
+    help_string = "Manage cognee configuration settings"
+    docs_url = DEFAULT_DOCS_URL
+    description = """
+The `cognee config` command allows you to view and modify configuration settings.
+
+You can:
+- View all current configuration settings
+- Get specific configuration values  
+- Set configuration values
+- Unset (reset to default) specific configuration values
+- Reset all configuration to defaults
+
+Configuration changes will affect how cognee processes and stores data.
+    """
+
+    def configure_parser(self, parser: argparse.ArgumentParser) -> None:
+        subparsers = parser.add_subparsers(dest="config_action", help="Configuration actions")
+
+        # Get command
+        get_parser = subparsers.add_parser("get", help="Get configuration value(s)")
+        get_parser.add_argument(
+            "key", nargs="?", help="Configuration key to retrieve (shows all if not specified)"
+        )
+
+        # Set command
+        set_parser = subparsers.add_parser("set", help="Set configuration value")
+        set_parser.add_argument("key", help="Configuration key to set")
+        set_parser.add_argument("value", help="Configuration value to set")
+
+        # List command
+        subparsers.add_parser("list", help="List all configuration keys")
+
+        # Unset command
+        unset_parser = subparsers.add_parser("unset", help="Remove/unset a configuration value")
+        unset_parser.add_argument("key", help="Configuration key to unset")
+        unset_parser.add_argument(
+            "--force", "-f", action="store_true", help="Skip confirmation prompt"
+        )
+
+        # Reset command
+        reset_parser = subparsers.add_parser("reset", help="Reset configuration to defaults")
+        reset_parser.add_argument(
+            "--force", "-f", action="store_true", help="Skip confirmation prompt"
+        )
+
+    def execute(self, args: argparse.Namespace) -> None:
+        try:
+            # Import cognee here to avoid circular imports
+            import cognee
+
+            if not hasattr(args, "config_action") or args.config_action is None:
+                fmt.error("Please specify a config action: get, set, unset, list, or reset")
+                return
+
+            if args.config_action == "get":
+                self._handle_get(args)
+            elif args.config_action == "set":
+                self._handle_set(args)
+            elif args.config_action == "unset":
+                self._handle_unset(args)
+            elif args.config_action == "list":
+                self._handle_list(args)
+            elif args.config_action == "reset":
+                self._handle_reset(args)
+            else:
+                fmt.error(f"Unknown config action: {args.config_action}")
+
+        except Exception as e:
+            if isinstance(e, CliCommandInnerException):
+                raise CliCommandException(str(e), error_code=1)
+            raise CliCommandException(f"Error managing configuration: {str(e)}", error_code=1)
+
+    def _handle_get(self, args: argparse.Namespace) -> None:
+        try:
+            import cognee
+
+            if args.key:
+                # Get specific key
+                try:
+                    if hasattr(cognee.config, "get"):
+                        value = cognee.config.get(args.key)
+                        fmt.echo(f"{args.key}: {value}")
+                    else:
+                        fmt.error("Configuration retrieval not implemented yet")
+                        fmt.note(
+                            "The config system currently only supports setting values, not retrieving them"
+                        )
+                        fmt.note(f"To set this value: 'cognee config set {args.key} <value>'")
+                except Exception:
+                    fmt.error(f"Configuration key '{args.key}' not found or retrieval failed")
+            else:
+                # Get all configuration
+                try:
+                    if hasattr(cognee.config, "get_all"):
+                        config_dict = cognee.config.get_all()
+                        if config_dict:
+                            fmt.echo("Current configuration:")
+                            for key, value in config_dict.items():
+                                fmt.echo(f"  {key}: {value}")
+                        else:
+                            fmt.echo("No configuration settings found")
+                    else:
+                        fmt.error("Configuration viewing not implemented yet")
+                        fmt.note(
+                            "The config system currently only supports setting values, not retrieving them"
+                        )
+                        fmt.note("Available commands: 'cognee config set <key> <value>'")
+                except Exception:
+                    fmt.error("Failed to retrieve configuration")
+                    fmt.note("Configuration viewing not fully implemented yet")
+
+        except Exception as e:
+            raise CliCommandInnerException(f"Failed to get configuration: {str(e)}")
+
+    def _handle_set(self, args: argparse.Namespace) -> None:
+        try:
+            import cognee
+
+            # Try to parse value as JSON, otherwise treat as string
+            try:
+                value = json.loads(args.value)
+            except json.JSONDecodeError:
+                value = args.value
+
+            try:
+                cognee.config.set(args.key, value)
+                fmt.success(f"Set {args.key} = {value}")
+            except Exception:
+                fmt.error(f"Failed to set configuration key '{args.key}'")
+
+        except Exception as e:
+            raise CliCommandInnerException(f"Failed to set configuration: {str(e)}")
+
+    def _handle_unset(self, args: argparse.Namespace) -> None:
+        try:
+            import cognee
+
+            # Confirm unset unless forced
+            if not args.force:
+                if not fmt.confirm(f"Unset configuration key '{args.key}'?"):
+                    fmt.echo("Unset cancelled.")
+                    return
+
+            # Since the config system doesn't have explicit unset methods,
+            # we need to map config keys to their reset/default behaviors
+            config_key_mappings = {
+                # LLM configuration
+                "llm_provider": ("set_llm_provider", "openai"),
+                "llm_model": ("set_llm_model", "gpt-5-mini"),
+                "llm_api_key": ("set_llm_api_key", ""),
+                "llm_endpoint": ("set_llm_endpoint", ""),
+                # Database configuration
+                "graph_database_provider": ("set_graph_database_provider", "kuzu"),
+                "vector_db_provider": ("set_vector_db_provider", "lancedb"),
+                "vector_db_url": ("set_vector_db_url", ""),
+                "vector_db_key": ("set_vector_db_key", ""),
+                # Chunking configuration
+                "chunk_size": ("set_chunk_size", 1500),
+                "chunk_overlap": ("set_chunk_overlap", 10),
+            }
+
+            if args.key in config_key_mappings:
+                method_name, default_value = config_key_mappings[args.key]
+
+                try:
+                    # Get the method and call it with the default value
+                    method = getattr(cognee.config, method_name)
+                    method(default_value)
+                    fmt.success(f"Unset {args.key} (reset to default: {default_value})")
+                except AttributeError:
+                    fmt.error(f"Configuration method '{method_name}' not found")
+                except Exception as e:
+                    fmt.error(f"Failed to unset '{args.key}': {str(e)}")
+            else:
+                fmt.error(f"Unknown configuration key '{args.key}'")
+                fmt.note("Available keys: " + ", ".join(config_key_mappings.keys()))
+                fmt.note("Use 'cognee config list' to see all available configuration options")
+
+        except Exception as e:
+            raise CliCommandInnerException(f"Failed to unset configuration: {str(e)}")
+
+    def _handle_list(self, args: argparse.Namespace) -> None:
+        try:
+            import cognee
+
+            # This would need to be implemented in cognee.config
+            fmt.note("Available configuration keys:")
+            fmt.echo("  llm_provider, llm_model, llm_api_key, llm_endpoint")
+            fmt.echo("  graph_database_provider, vector_db_provider")
+            fmt.echo("  vector_db_url, vector_db_key")
+            fmt.echo("  chunk_size, chunk_overlap")
+            fmt.echo("")
+            fmt.echo("Commands:")
+            fmt.echo("  cognee config get [key]     - View configuration")
+            fmt.echo("  cognee config set <key> <value> - Set configuration")
+            fmt.echo("  cognee config unset <key>   - Reset key to default")
+            fmt.echo("  cognee config reset         - Reset all to defaults")
+
+        except Exception as e:
+            raise CliCommandInnerException(f"Failed to list configuration: {str(e)}")
+
+    def _handle_reset(self, args: argparse.Namespace) -> None:
+        try:
+            if not args.force:
+                if not fmt.confirm("Reset all configuration to defaults?"):
+                    fmt.echo("Reset cancelled.")
+                    return
+
+            fmt.note("Configuration reset not fully implemented yet")
+            fmt.echo("This would reset all settings to their default values")
+
+        except Exception as e:
+            raise CliCommandInnerException(f"Failed to reset configuration: {str(e)}")

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())