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

cognee/cli/commands/cognify_command.py

@@ -0,0 +1,128 @@
+import argparse
+import asyncio
+from typing import Optional
+
+from cognee.cli.reference import SupportsCliCommand
+from cognee.cli import DEFAULT_DOCS_URL
+from cognee.cli.config import CHUNKER_CHOICES
+import cognee.cli.echo as fmt
+from cognee.cli.exceptions import CliCommandException, CliCommandInnerException
+
+
+class CognifyCommand(SupportsCliCommand):
+    command_string = "cognify"
+    help_string = "Transform ingested data into a structured knowledge graph"
+    docs_url = DEFAULT_DOCS_URL
+    description = """
+Transform ingested data into a structured knowledge graph.
+
+This is the core processing step in Cognee that converts raw text and documents
+into an intelligent knowledge graph. It analyzes content, extracts entities and
+relationships, and creates semantic connections for enhanced search and reasoning.
+
+Processing Pipeline:
+1. **Document Classification**: Identifies document types and structures
+2. **Permission Validation**: Ensures user has processing rights  
+3. **Text Chunking**: Breaks content into semantically meaningful segments
+4. **Entity Extraction**: Identifies key concepts, people, places, organizations
+5. **Relationship Detection**: Discovers connections between entities
+6. **Graph Construction**: Builds semantic knowledge graph with embeddings
+7. **Content Summarization**: Creates hierarchical summaries for navigation
+
+After successful cognify processing, use `cognee search` to query the knowledge graph.
+    """
+
+    def configure_parser(self, parser: argparse.ArgumentParser) -> None:
+        parser.add_argument(
+            "--datasets",
+            "-d",
+            nargs="*",
+            help="Dataset name(s) to process. Processes all available data if not specified. Can be multiple: --datasets dataset1 dataset2",
+        )
+        parser.add_argument(
+            "--chunk-size",
+            type=int,
+            help="Maximum tokens per chunk. Auto-calculated based on LLM if not specified (~512-8192 tokens)",
+        )
+        parser.add_argument(
+            "--ontology-file", help="Path to RDF/OWL ontology file for domain-specific entity types"
+        )
+        parser.add_argument(
+            "--chunker",
+            choices=CHUNKER_CHOICES,
+            default="TextChunker",
+            help="Text chunking strategy (default: TextChunker)",
+        )
+        parser.add_argument(
+            "--background",
+            "-b",
+            action="store_true",
+            help="Run processing in background and return immediately (recommended for large datasets)",
+        )
+        parser.add_argument(
+            "--verbose", "-v", action="store_true", help="Show detailed progress information"
+        )
+
+    def execute(self, args: argparse.Namespace) -> None:
+        try:
+            # Import cognee here to avoid circular imports
+            import cognee
+
+            # Prepare datasets parameter
+            datasets = args.datasets if args.datasets else None
+            dataset_msg = f" for datasets {datasets}" if datasets else " for all available data"
+            fmt.echo(f"Starting cognification{dataset_msg}...")
+
+            if args.verbose:
+                fmt.note("This process will analyze your data and build knowledge graphs.")
+                fmt.note("Depending on data size, this may take several minutes.")
+                if args.background:
+                    fmt.note(
+                        "Running in background mode - the process will continue after this command exits."
+                    )
+
+            # Prepare chunker parameter - will be handled in the async function
+
+            # Run the async cognify function
+            async def run_cognify():
+                try:
+                    # Import chunker classes here
+                    from cognee.modules.chunking.TextChunker import TextChunker
+
+                    chunker_class = TextChunker  # Default
+                    if args.chunker == "LangchainChunker":
+                        try:
+                            from cognee.modules.chunking.LangchainChunker import LangchainChunker
+
+                            chunker_class = LangchainChunker
+                        except ImportError:
+                            fmt.warning("LangchainChunker not available, using TextChunker")
+
+                    result = await cognee.cognify(
+                        datasets=datasets,
+                        chunker=chunker_class,
+                        chunk_size=args.chunk_size,
+                        ontology_file_path=args.ontology_file,
+                        run_in_background=args.background,
+                    )
+                    return result
+                except Exception as e:
+                    raise CliCommandInnerException(f"Failed to cognify: {str(e)}")
+
+            result = asyncio.run(run_cognify())
+
+            if args.background:
+                fmt.success("Cognification started in background!")
+                if args.verbose and result:
+                    fmt.echo(
+                        "Background processing initiated. Use pipeline monitoring to track progress."
+                    )
+            else:
+                fmt.success("Cognification completed successfully!")
+                if args.verbose and result:
+                    fmt.echo(f"Processing results: {result}")
+
+        except Exception as e:
+            if isinstance(e, CliCommandInnerException):
+                raise CliCommandException(str(e), error_code=1)
+            raise CliCommandException(f"Error during cognification: {str(e)}", error_code=1)

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)