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

cognee/__main__.py

@@ -0,0 +1,4 @@
+from cognee.cli._cognee import main
+
+if __name__ == "__main__":
+    main()

cognee/api/v1/add/add.py

@@ -1,9 +1,15 @@
 from uuid import UUID
 from typing import Union, BinaryIO, List, Optional
 
-from cognee.modules.pipelines import Task
 from cognee.modules.users.models import User
-from cognee.modules.pipelines import cognee_pipeline
+from cognee.modules.pipelines import Task, run_pipeline
+from cognee.modules.pipelines.layers.resolve_authorized_user_dataset import (
+    resolve_authorized_user_dataset,
+)
+from cognee.modules.pipelines.layers.reset_dataset_pipeline_run_status import (
+    reset_dataset_pipeline_run_status,
+)
+from cognee.modules.engine.operations.setup import setup
 from cognee.tasks.ingestion import ingest_data, resolve_data_directories
 
 
@@ -128,11 +134,11 @@ async def add(
 
         Optional:
         - LLM_PROVIDER: "openai" (default), "anthropic", "gemini", "ollama"
-        - LLM_MODEL: Model name (default: "gpt-4o-mini")
+        - LLM_MODEL: Model name (default: "gpt-5-mini")
         - DEFAULT_USER_EMAIL: Custom default user email
         - DEFAULT_USER_PASSWORD: Custom default user password
         - VECTOR_DB_PROVIDER: "lancedb" (default), "chromadb", "pgvector"
-        - GRAPH_DATABASE_PROVIDER: "kuzu" (default), "neo4j", "networkx"
+        - GRAPH_DATABASE_PROVIDER: "kuzu" (default), "neo4j"
 
     """
     tasks = [
@@ -140,11 +146,17 @@ async def add(
         Task(ingest_data, dataset_name, user, node_set, dataset_id, preferred_loaders),
     ]
 
+    await setup()
+
+    user, authorized_dataset = await resolve_authorized_user_dataset(dataset_id, dataset_name, user)
+
+    await reset_dataset_pipeline_run_status(authorized_dataset.id, user)
+
     pipeline_run_info = None
 
-    async for run_info in cognee_pipeline(
+    async for run_info in run_pipeline(
         tasks=tasks,
-        datasets=dataset_id if dataset_id else dataset_name,
+        datasets=[authorized_dataset.id],
         data=data,
         user=user,
         pipeline_name="add_pipeline",

cognee/api/v1/cognify/code_graph_pipeline.py

@@ -40,8 +40,14 @@ async def run_code_graph_pipeline(repo_path, include_docs=False):
     user = await get_default_user()
     detailed_extraction = True
 
+    # Multi-language support: allow passing supported_languages
+    supported_languages = None  # defer to task defaults
     tasks = [
-        Task(get_repo_file_dependencies, detailed_extraction=detailed_extraction),
+        Task(
+            get_repo_file_dependencies,
+            detailed_extraction=detailed_extraction,
+            supported_languages=supported_languages,
+        ),
         # Task(summarize_code, task_config={"batch_size": 500}), # This task takes a long time to complete
         Task(add_data_points, task_config={"batch_size": 30}),
     ]

cognee/api/v1/cognify/cognify.py

@@ -7,12 +7,10 @@ from cognee.shared.logging_utils import get_logger
 from cognee.shared.data_models import KnowledgeGraph
 from cognee.infrastructure.llm import get_max_chunk_tokens
 
-from cognee.modules.pipelines import cognee_pipeline
+from cognee.modules.pipelines import run_pipeline
 from cognee.modules.pipelines.tasks.task import Task
 from cognee.modules.chunking.TextChunker import TextChunker
 from cognee.modules.ontology.rdf_xml.OntologyResolver import OntologyResolver
-from cognee.modules.pipelines.models.PipelineRunInfo import PipelineRunCompleted, PipelineRunErrored
-from cognee.modules.pipelines.queues.pipeline_run_info_queues import push_to_queue
 from cognee.modules.users.models import User
 
 from cognee.tasks.documents import (
@@ -23,6 +21,7 @@ from cognee.tasks.documents import (
 from cognee.tasks.graph import extract_graph_from_data
 from cognee.tasks.storage import add_data_points
 from cognee.tasks.summarization import summarize_text
+from cognee.modules.pipelines.layers.pipeline_execution_mode import get_pipeline_executor
 
 logger = get_logger("cognify")
 
@@ -40,6 +39,7 @@ async def cognify(
     graph_db_config: dict = None,
     run_in_background: bool = False,
     incremental_loading: bool = True,
+    custom_prompt: Optional[str] = None,
 ):
     """
     Transform ingested data into a structured knowledge graph.
@@ -91,7 +91,7 @@ async def cognify(
                 - LangchainChunker: Recursive character splitting with overlap
                 Determines how documents are segmented for processing.
         chunk_size: Maximum tokens per chunk. Auto-calculated based on LLM if None.
-                   Formula: min(embedding_max_tokens, llm_max_tokens // 2)
+                   Formula: min(embedding_max_completion_tokens, llm_max_completion_tokens // 2)
                    Default limits: ~512-8192 tokens depending on models.
                    Smaller chunks = more granular but potentially fragmented knowledge.
         ontology_file_path: Path to RDF/OWL ontology file for domain-specific entity types.
@@ -102,6 +102,10 @@ async def cognify(
                           If False, waits for completion before returning.
                           Background mode recommended for large datasets (>100MB).
                           Use pipeline_run_id from return value to monitor progress.
+        custom_prompt: Optional custom prompt string to use for entity extraction and graph generation.
+                      If provided, this prompt will be used instead of the default prompts for
+                      knowledge graph extraction. The prompt should guide the LLM on how to
+                      extract entities and relationships from the text content.
 
     Returns:
         Union[dict, list[PipelineRunInfo]]:
@@ -178,115 +182,24 @@ async def cognify(
         - LLM_RATE_LIMIT_ENABLED: Enable rate limiting (default: False)
         - LLM_RATE_LIMIT_REQUESTS: Max requests per interval (default: 60)
     """
-    tasks = await get_default_tasks(user, graph_model, chunker, chunk_size, ontology_file_path)
-
-    if run_in_background:
-        return await run_cognify_as_background_process(
-            tasks=tasks,
-            user=user,
-            datasets=datasets,
-            vector_db_config=vector_db_config,
-            graph_db_config=graph_db_config,
-            incremental_loading=incremental_loading,
-        )
-    else:
-        return await run_cognify_blocking(
-            tasks=tasks,
-            user=user,
-            datasets=datasets,
-            vector_db_config=vector_db_config,
-            graph_db_config=graph_db_config,
-            incremental_loading=incremental_loading,
-        )
-
+    tasks = await get_default_tasks(
+        user, graph_model, chunker, chunk_size, ontology_file_path, custom_prompt
+    )
 
-async def run_cognify_blocking(
-    tasks,
-    user,
-    datasets,
-    graph_db_config: dict = None,
-    vector_db_config: dict = False,
-    incremental_loading: bool = True,
-):
-    total_run_info = {}
+    # By calling get pipeline executor we get a function that will have the run_pipeline run in the background or a function that we will need to wait for
+    pipeline_executor_func = get_pipeline_executor(run_in_background=run_in_background)
 
-    async for run_info in cognee_pipeline(
+    # Run the run_pipeline in the background or blocking based on executor
+    return await pipeline_executor_func(
+        pipeline=run_pipeline,
         tasks=tasks,
-        datasets=datasets,
         user=user,
-        pipeline_name="cognify_pipeline",
-        graph_db_config=graph_db_config,
+        datasets=datasets,
         vector_db_config=vector_db_config,
+        graph_db_config=graph_db_config,
         incremental_loading=incremental_loading,
-    ):
-        if run_info.dataset_id:
-            total_run_info[run_info.dataset_id] = run_info
-        else:
-            total_run_info = run_info
-
-    return total_run_info
-
-
-async def run_cognify_as_background_process(
-    tasks,
-    user,
-    datasets,
-    graph_db_config: dict = None,
-    vector_db_config: dict = False,
-    incremental_loading: bool = True,
-):
-    # Convert dataset to list if it's a string
-    if isinstance(datasets, str):
-        datasets = [datasets]
-
-    # Store pipeline status for all pipelines
-    pipeline_run_started_info = {}
-
-    async def handle_rest_of_the_run(pipeline_list):
-        # Execute all provided pipelines one by one to avoid database write conflicts
-        # TODO: Convert to async gather task instead of for loop when Queue mechanism for database is created
-        for pipeline in pipeline_list:
-            while True:
-                try:
-                    pipeline_run_info = await anext(pipeline)
-
-                    push_to_queue(pipeline_run_info.pipeline_run_id, pipeline_run_info)
-
-                    if isinstance(pipeline_run_info, PipelineRunCompleted) or isinstance(
-                        pipeline_run_info, PipelineRunErrored
-                    ):
-                        break
-                except StopAsyncIteration:
-                    break
-
-    # Start all pipelines to get started status
-    pipeline_list = []
-    for dataset in datasets:
-        pipeline_run = cognee_pipeline(
-            tasks=tasks,
-            user=user,
-            datasets=dataset,
-            pipeline_name="cognify_pipeline",
-            graph_db_config=graph_db_config,
-            vector_db_config=vector_db_config,
-            incremental_loading=incremental_loading,
-        )
-
-        # Save dataset Pipeline run started info
-        run_info = await anext(pipeline_run)
-        pipeline_run_started_info[run_info.dataset_id] = run_info
-
-        if pipeline_run_started_info[run_info.dataset_id].payload:
-            # Remove payload info to avoid serialization
-            # TODO: Handle payload serialization
-            pipeline_run_started_info[run_info.dataset_id].payload = []
-
-        pipeline_list.append(pipeline_run)
-
-    # Send all started pipelines to execute one by one in background
-    asyncio.create_task(handle_rest_of_the_run(pipeline_list=pipeline_list))
-
-    return pipeline_run_started_info
+        pipeline_name="cognify_pipeline",
+    )
 
 
 async def get_default_tasks(  # TODO: Find out a better way to do this (Boris's comment)
@@ -295,6 +208,7 @@ async def get_default_tasks(  # TODO: Find out a better way to do this (Boris's
     chunker=TextChunker,
     chunk_size: int = None,
     ontology_file_path: Optional[str] = None,
+    custom_prompt: Optional[str] = None,
 ) -> list[Task]:
     default_tasks = [
         Task(classify_documents),
@@ -308,6 +222,7 @@ async def get_default_tasks(  # TODO: Find out a better way to do this (Boris's
             extract_graph_from_data,
             graph_model=graph_model,
             ontology_adapter=OntologyResolver(ontology_file=ontology_file_path),
+            custom_prompt=custom_prompt,
             task_config={"batch_size": 10},
         ),  # Generate knowledge graphs from the document chunks.
         Task(

cognee/api/v1/cognify/routers/get_cognify_router.py

@@ -37,6 +37,9 @@ class CognifyPayloadDTO(InDTO):
     datasets: Optional[List[str]] = Field(default=None)
     dataset_ids: Optional[List[UUID]] = Field(default=None, examples=[[]])
     run_in_background: Optional[bool] = Field(default=False)
+    custom_prompt: Optional[str] = Field(
+        default=None, description="Custom prompt for entity extraction and graph generation"
+    )
 
 
 def get_cognify_router() -> APIRouter:
@@ -63,6 +66,7 @@ def get_cognify_router() -> APIRouter:
         - **datasets** (Optional[List[str]]): List of dataset names to process. Dataset names are resolved to datasets owned by the authenticated user.
         - **dataset_ids** (Optional[List[UUID]]): List of existing dataset UUIDs to process. UUIDs allow processing of datasets not owned by the user (if permitted).
         - **run_in_background** (Optional[bool]): Whether to execute processing asynchronously. Defaults to False (blocking).
+        - **custom_prompt** (Optional[str]): Custom prompt for entity extraction and graph generation. If provided, this prompt will be used instead of the default prompts for knowledge graph extraction.
 
         ## Response
         - **Blocking execution**: Complete pipeline run information with entity counts, processing duration, and success/failure status
@@ -76,7 +80,8 @@ def get_cognify_router() -> APIRouter:
         ```json
         {
             "datasets": ["research_papers", "documentation"],
-            "run_in_background": false
+            "run_in_background": false,
+            "custom_prompt": "Extract entities focusing on technical concepts and their relationships. Identify key technologies, methodologies, and their interconnections."
         }
         ```
 
@@ -106,7 +111,10 @@ def get_cognify_router() -> APIRouter:
             datasets = payload.dataset_ids if payload.dataset_ids else payload.datasets
 
             cognify_run = await cognee_cognify(
-                datasets, user, run_in_background=payload.run_in_background
+                datasets,
+                user,
+                run_in_background=payload.run_in_background,
+                custom_prompt=payload.custom_prompt,
             )
 
             # If any cognify run errored return JSONResponse with proper error status code
@@ -164,7 +172,7 @@ def get_cognify_router() -> APIRouter:
                     {
                         "pipeline_run_id": str(pipeline_run_info.pipeline_run_id),
                         "status": pipeline_run_info.status,
-                        "payload": await get_formatted_graph_data(pipeline_run.dataset_id, user.id),
+                        "payload": await get_formatted_graph_data(pipeline_run.dataset_id, user),
                     }
                 )
 

cognee/api/v1/datasets/routers/get_datasets_router.py

@@ -284,7 +284,7 @@ def get_datasets_router() -> APIRouter:
         - **500 Internal Server Error**: Error retrieving graph data
         """
 
-        graph_data = await get_formatted_graph_data(dataset_id, user.id)
+        graph_data = await get_formatted_graph_data(dataset_id, user)
 
         return graph_data
 

cognee/api/v1/responses/default_tools.py

@@ -49,6 +49,10 @@ DEFAULT_TOOLS = [
                     "type": "string",
                     "description": "Path to a custom ontology file",
                 },
+                "custom_prompt": {
+                    "type": "string",
+                    "description": "Custom prompt for entity extraction and graph generation. If provided, this prompt will be used instead of the default prompts.",
+                },
             },
             "required": ["text"],
         },

cognee/api/v1/responses/dispatch_function.py

@@ -88,11 +88,16 @@ async def handle_cognify(arguments: Dict[str, Any], user) -> str:
     """Handle cognify function call"""
     text = arguments.get("text")
     ontology_file_path = arguments.get("ontology_file_path")
+    custom_prompt = arguments.get("custom_prompt")
 
     if text:
         await add(data=text, user=user)
 
-    await cognify(user=user, ontology_file_path=ontology_file_path if ontology_file_path else None)
+    await cognify(
+        user=user,
+        ontology_file_path=ontology_file_path if ontology_file_path else None,
+        custom_prompt=custom_prompt,
+    )
 
     return (
         "Text successfully converted into knowledge graph."

cognee/api/v1/responses/models.py

@@ -70,7 +70,7 @@ class ResponseRequest(InDTO):
     tool_choice: Optional[Union[str, Dict[str, Any]]] = "auto"
     user: Optional[str] = None
     temperature: Optional[float] = 1.0
-    max_tokens: Optional[int] = None
+    max_completion_tokens: Optional[int] = None
 
 
 class ToolCallOutput(BaseModel):

cognee/api/v1/search/search.py

@@ -19,6 +19,8 @@ async def search(
     top_k: int = 10,
     node_type: Optional[Type] = None,
     node_name: Optional[List[str]] = None,
+    save_interaction: bool = False,
+    last_k: Optional[int] = None,
 ) -> list:
     """
     Search and query the knowledge graph for insights, information, and connections.
@@ -107,6 +109,8 @@ async def search(
 
         node_name: Filter results to specific named entities (for targeted search).
 
+        save_interaction: Save interaction (query, context, answer connected to triplet endpoints) results into the graph or not
+
     Returns:
         list: Search results in format determined by query_type:
 
@@ -182,6 +186,8 @@ async def search(
         top_k=top_k,
         node_type=node_type,
         node_name=node_name,
+        save_interaction=save_interaction,
+        last_k=last_k,
     )
 
     return filtered_search_results

cognee/cli/__init__.py

@@ -0,0 +1,10 @@
+from cognee.cli.reference import SupportsCliCommand
+from cognee.cli.exceptions import CliCommandException
+
+DEFAULT_DOCS_URL = "https://docs.cognee.ai"
+
+__all__ = [
+    "SupportsCliCommand",
+    "CliCommandException",
+    "DEFAULT_DOCS_URL",
+]

cognee/cli/_cognee.py

@@ -0,0 +1,180 @@
+import sys
+import os
+import argparse
+from typing import Any, Sequence, Dict, Type, cast, List
+import click
+
+try:
+    import rich_argparse
+    from rich.markdown import Markdown
+
+    HAS_RICH = True
+except ImportError:
+    HAS_RICH = False
+
+from cognee.cli import SupportsCliCommand, DEFAULT_DOCS_URL
+from cognee.cli.config import CLI_DESCRIPTION
+from cognee.cli import debug
+import cognee.cli.echo as fmt
+from cognee.cli.exceptions import CliCommandException
+
+
+ACTION_EXECUTED = False
+
+
+def print_help(parser: argparse.ArgumentParser) -> None:
+    if not ACTION_EXECUTED:
+        parser.print_help()
+
+
+class DebugAction(argparse.Action):
+    def __init__(
+        self,
+        option_strings: Sequence[str],
+        dest: Any = argparse.SUPPRESS,
+        default: Any = argparse.SUPPRESS,
+        help: str = None,
+    ) -> None:
+        super(DebugAction, self).__init__(
+            option_strings=option_strings, dest=dest, default=default, nargs=0, help=help
+        )
+
+    def __call__(
+        self,
+        parser: argparse.ArgumentParser,
+        namespace: argparse.Namespace,
+        values: Any,
+        option_string: str = None,
+    ) -> None:
+        # Enable debug mode for stack traces
+        debug.enable_debug()
+        fmt.note("Debug mode enabled. Full stack traces will be shown.")
+
+
+# Debug functionality is now in cognee.cli.debug module
+
+
+def _discover_commands() -> List[Type[SupportsCliCommand]]:
+    """Discover all available CLI commands"""
+    # Import commands dynamically to avoid early cognee initialization
+    commands = []
+
+    command_modules = [
+        ("cognee.cli.commands.add_command", "AddCommand"),
+        ("cognee.cli.commands.search_command", "SearchCommand"),
+        ("cognee.cli.commands.cognify_command", "CognifyCommand"),
+        ("cognee.cli.commands.delete_command", "DeleteCommand"),
+        ("cognee.cli.commands.config_command", "ConfigCommand"),
+    ]
+
+    for module_path, class_name in command_modules:
+        try:
+            module = __import__(module_path, fromlist=[class_name])
+            command_class = getattr(module, class_name)
+            commands.append(command_class)
+        except (ImportError, AttributeError) as e:
+            fmt.warning(f"Failed to load command {class_name}: {e}")
+
+    return commands
+
+
+def _create_parser() -> tuple[argparse.ArgumentParser, Dict[str, SupportsCliCommand]]:
+    parser = argparse.ArgumentParser(
+        description=f"{CLI_DESCRIPTION} Further help is available at {DEFAULT_DOCS_URL}."
+    )
+
+    # Get version dynamically
+    try:
+        from cognee.version import get_cognee_version
+
+        version = get_cognee_version()
+    except ImportError:
+        version = "unknown"
+
+    parser.add_argument("--version", action="version", version=f"cognee {version}")
+    parser.add_argument(
+        "--debug",
+        action=DebugAction,
+        help="Enable debug mode to show full stack traces on exceptions",
+    )
+
+    subparsers = parser.add_subparsers(title="Available commands", dest="command")
+
+    # Discover and install commands
+    command_classes = _discover_commands()
+    installed_commands: Dict[str, SupportsCliCommand] = {}
+
+    for command_class in command_classes:
+        command = command_class()
+        if command.command_string in installed_commands:
+            continue
+
+        command_parser = subparsers.add_parser(
+            command.command_string,
+            help=command.help_string,
+            description=command.description if hasattr(command, "description") else None,
+        )
+        command.configure_parser(command_parser)
+        installed_commands[command.command_string] = command
+
+    # Add rich formatting if available
+    if HAS_RICH:
+
+        def add_formatter_class(parser: argparse.ArgumentParser) -> None:
+            parser.formatter_class = rich_argparse.RichHelpFormatter
+
+            if parser.description:
+                parser.description = Markdown(parser.description, style="argparse.text")
+            for action in parser._actions:
+                if isinstance(action, argparse._SubParsersAction):
+                    for _subcmd, subparser in action.choices.items():
+                        add_formatter_class(subparser)
+
+        add_formatter_class(parser)
+
+    return parser, installed_commands
+
+
+def main() -> int:
+    """Main CLI entry point"""
+    parser, installed_commands = _create_parser()
+    args = parser.parse_args()
+
+    if cmd := installed_commands.get(args.command):
+        try:
+            cmd.execute(args)
+        except Exception as ex:
+            docs_url = cmd.docs_url if hasattr(cmd, "docs_url") else DEFAULT_DOCS_URL
+            error_code = -1
+            raiseable_exception = ex
+
+            # Handle CLI-specific exceptions
+            if isinstance(ex, CliCommandException):
+                error_code = ex.error_code
+                docs_url = ex.docs_url or docs_url
+                raiseable_exception = ex.raiseable_exception
+
+            # Print exception
+            if raiseable_exception:
+                fmt.error(str(ex))
+
+            fmt.note(f"Please refer to our docs at '{docs_url}' for further assistance.")
+
+            if debug.is_debug_enabled() and raiseable_exception:
+                raise raiseable_exception
+
+            return error_code
+    else:
+        print_help(parser)
+        return -1
+
+    return 0
+
+
+def _main() -> None:
+    """Script entry point"""
+    sys.exit(main())
+
+
+if __name__ == "__main__":
+    sys.exit(main())

cognee/cli/commands/__init__.py

@@ -0,0 +1 @@
+# CLI Commands package

cognee/cli/commands/add_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 AddCommand(SupportsCliCommand):
+    command_string = "add"
+    help_string = "Add data to Cognee for knowledge graph processing"
+    docs_url = DEFAULT_DOCS_URL
+    description = """
+Add data to Cognee for knowledge graph processing.
+
+This is the first step in the Cognee workflow - it ingests raw data and prepares it
+for processing. The function accepts various data formats including text, files, and
+binary streams, then stores them in a specified dataset for further processing.
+
+Supported Input Types:
+- **Text strings**: Direct text content
+- **File paths**: Local file paths (absolute paths starting with "/")  
+- **File URLs**: "file:///absolute/path" or "file://relative/path"
+- **S3 paths**: "s3://bucket-name/path/to/file"
+- **Lists**: Multiple files or text strings in a single call
+
+Supported File Formats:
+- Text files (.txt, .md, .csv)
+- PDFs (.pdf)
+- Images (.png, .jpg, .jpeg) - extracted via OCR/vision models
+- Audio files (.mp3, .wav) - transcribed to text
+- Code files (.py, .js, .ts, etc.) - parsed for structure and content
+- Office documents (.docx, .pptx)
+
+After adding data, use `cognee cognify` to process it into knowledge graphs.
+    """
+
+    def configure_parser(self, parser: argparse.ArgumentParser) -> None:
+        parser.add_argument(
+            "data",
+            nargs="+",
+            help="Data to add: text content, file paths (/path/to/file), file URLs (file://path), S3 paths (s3://bucket/file), or mix of these",
+        )
+        parser.add_argument(
+            "--dataset-name",
+            "-d",
+            default="main_dataset",
+            help="Dataset name to organize your data (default: main_dataset)",
+        )
+
+    def execute(self, args: argparse.Namespace) -> None:
+        try:
+            # Import cognee here to avoid circular imports
+            import cognee
+
+            fmt.echo(f"Adding {len(args.data)} item(s) to dataset '{args.dataset_name}'...")
+
+            # Run the async add function
+            async def run_add():
+                try:
+                    # Pass all data items as a list to cognee.add if multiple items
+                    if len(args.data) == 1:
+                        data_to_add = args.data[0]
+                    else:
+                        data_to_add = args.data
+
+                    fmt.echo("Processing data...")
+                    await cognee.add(data=data_to_add, dataset_name=args.dataset_name)
+                    fmt.success(f"Successfully added data to dataset '{args.dataset_name}'")
+                except Exception as e:
+                    raise CliCommandInnerException(f"Failed to add data: {str(e)}")
+
+            asyncio.run(run_add())
+
+        except Exception as e:
+            if isinstance(e, CliCommandInnerException):
+                raise CliCommandException(str(e), error_code=1)
+            raise CliCommandException(f"Error adding data: {str(e)}", error_code=1)