cognee 0.3.4.dev3__py3-none-any.whl → 0.3.5__py3-none-any.whl

cognee/api/v1/ui/ui.py

@@ -1,5 +1,7 @@
 import os
+import platform
 import signal
+import socket
 import subprocess
 import threading
 import time
@@ -7,7 +9,7 @@ import webbrowser
 import zipfile
 import requests
 from pathlib import Path
-from typing import Callable, Optional, Tuple
+from typing import Callable, Optional, Tuple, List
 import tempfile
 import shutil
 
@@ -17,6 +19,80 @@ from cognee.version import get_cognee_version
 logger = get_logger()
 
 
+def _stream_process_output(
+    process: subprocess.Popen, stream_name: str, prefix: str, color_code: str = ""
+) -> threading.Thread:
+    """
+    Stream output from a process with a prefix to identify the source.
+
+    Args:
+        process: The subprocess to monitor
+        stream_name: 'stdout' or 'stderr'
+        prefix: Text prefix for each line (e.g., '[BACKEND]', '[FRONTEND]')
+        color_code: ANSI color code for the prefix (optional)
+
+    Returns:
+        Thread that handles the streaming
+    """
+
+    def stream_reader():
+        stream = getattr(process, stream_name)
+        if stream is None:
+            return
+
+        reset_code = "\033[0m" if color_code else ""
+
+        try:
+            for line in iter(stream.readline, b""):
+                if line:
+                    line_text = line.decode("utf-8").rstrip()
+                    if line_text:
+                        print(f"{color_code}{prefix}{reset_code} {line_text}", flush=True)
+        except Exception:
+            pass
+        finally:
+            if stream:
+                stream.close()
+
+    thread = threading.Thread(target=stream_reader, daemon=True)
+    thread.start()
+    return thread
+
+
+def _is_port_available(port: int) -> bool:
+    """
+    Check if a port is available on localhost.
+    Returns True if the port is available, False otherwise.
+    """
+    try:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+            sock.settimeout(1)  # 1 second timeout
+            result = sock.connect_ex(("localhost", port))
+            return result != 0  # Port is available if connection fails
+    except Exception:
+        return False
+
+
+def _check_required_ports(ports_to_check: List[Tuple[int, str]]) -> Tuple[bool, List[str]]:
+    """
+    Check if all required ports are available on localhost.
+
+    Args:
+        ports_to_check: List of (port, service_name) tuples
+
+    Returns:
+        Tuple of (all_available: bool, unavailable_services: List[str])
+    """
+    unavailable = []
+
+    for port, service_name in ports_to_check:
+        if not _is_port_available(port):
+            unavailable.append(f"{service_name} (port {port})")
+            logger.error(f"Port {port} is already in use for {service_name}")
+
+    return len(unavailable) == 0, unavailable
+
+
 def normalize_version_for_comparison(version: str) -> str:
     """
     Normalize version string for comparison.
@@ -214,6 +290,7 @@ def check_node_npm() -> tuple[bool, str]:
     Check if Node.js and npm are available.
     Returns (is_available, error_message)
     """
+
     try:
         # Check Node.js
         result = subprocess.run(["node", "--version"], capture_output=True, text=True, timeout=10)
@@ -223,8 +300,17 @@ def check_node_npm() -> tuple[bool, str]:
         node_version = result.stdout.strip()
         logger.debug(f"Found Node.js version: {node_version}")
 
-        # Check npm
-        result = subprocess.run(["npm", "--version"], capture_output=True, text=True, timeout=10)
+        # Check npm - handle Windows PowerShell scripts
+        if platform.system() == "Windows":
+            # On Windows, npm might be a PowerShell script, so we need to use shell=True
+            result = subprocess.run(
+                ["npm", "--version"], capture_output=True, text=True, timeout=10, shell=True
+            )
+        else:
+            result = subprocess.run(
+                ["npm", "--version"], capture_output=True, text=True, timeout=10
+            )
+
         if result.returncode != 0:
             return False, "npm is not installed or not in PATH"
 
@@ -246,6 +332,7 @@ def install_frontend_dependencies(frontend_path: Path) -> bool:
     Install frontend dependencies if node_modules doesn't exist.
     This is needed for both development and downloaded frontends since both use npm run dev.
     """
+
     node_modules = frontend_path / "node_modules"
     if node_modules.exists():
         logger.debug("Frontend dependencies already installed")
@@ -254,13 +341,24 @@ def install_frontend_dependencies(frontend_path: Path) -> bool:
     logger.info("Installing frontend dependencies (this may take a few minutes)...")
 
     try:
-        result = subprocess.run(
-            ["npm", "install"],
-            cwd=frontend_path,
-            capture_output=True,
-            text=True,
-            timeout=300,  # 5 minutes timeout
-        )
+        # Use shell=True on Windows for npm commands
+        if platform.system() == "Windows":
+            result = subprocess.run(
+                ["npm", "install"],
+                cwd=frontend_path,
+                capture_output=True,
+                text=True,
+                timeout=300,  # 5 minutes timeout
+                shell=True,
+            )
+        else:
+            result = subprocess.run(
+                ["npm", "install"],
+                cwd=frontend_path,
+                capture_output=True,
+                text=True,
+                timeout=300,  # 5 minutes timeout
+            )
 
         if result.returncode == 0:
             logger.info("Frontend dependencies installed successfully")
@@ -327,55 +425,111 @@ def prompt_user_for_download() -> bool:
 
 def start_ui(
     pid_callback: Callable[[int], None],
-    host: str = "localhost",
     port: int = 3000,
     open_browser: bool = True,
     auto_download: bool = False,
     start_backend: bool = False,
-    backend_host: str = "localhost",
     backend_port: int = 8000,
+    start_mcp: bool = False,
+    mcp_port: int = 8001,
 ) -> Optional[subprocess.Popen]:
     """
-    Start the cognee frontend UI server, optionally with the backend API server.
+    Start the cognee frontend UI server, optionally with the backend API server and MCP server.
 
     This function will:
     1. Optionally start the cognee backend API server
-    2. Find the cognee-frontend directory (development) or download it (pip install)
-    3. Check if Node.js and npm are available (for development mode)
-    4. Install dependencies if needed (development mode)
-    5. Start the frontend server
-    6. Optionally open the browser
+    2. Optionally start the cognee MCP server
+    3. Find the cognee-frontend directory (development) or download it (pip install)
+    4. Check if Node.js and npm are available (for development mode)
+    5. Install dependencies if needed (development mode)
+    6. Start the frontend server
+    7. Optionally open the browser
 
     Args:
         pid_callback: Callback to notify with PID of each spawned process
-        host: Host to bind the frontend server to (default: localhost)
         port: Port to run the frontend server on (default: 3000)
         open_browser: Whether to open the browser automatically (default: True)
         auto_download: If True, download frontend without prompting (default: False)
         start_backend: If True, also start the cognee API backend server (default: False)
-        backend_host: Host to bind the backend server to (default: localhost)
         backend_port: Port to run the backend server on (default: 8000)
+        start_mcp: If True, also start the cognee MCP server (default: False)
+        mcp_port: Port to run the MCP server on (default: 8001)
 
     Returns:
         subprocess.Popen object representing the running frontend server, or None if failed
-        Note: If backend is started, it runs in a separate process that will be cleaned up
-        when the frontend process is terminated.
+        Note: If backend and/or MCP server are started, they run in separate processes
+        that will be cleaned up when the frontend process is terminated.
 
     Example:
         >>> import cognee
+        >>> def dummy_callback(pid): pass
         >>> # Start just the frontend
-        >>> server = cognee.start_ui()
+        >>> server = cognee.start_ui(dummy_callback)
         >>>
         >>> # Start both frontend and backend
-        >>> server = cognee.start_ui(start_backend=True)
+        >>> server = cognee.start_ui(dummy_callback, start_backend=True)
         >>> # UI will be available at http://localhost:3000
         >>> # API will be available at http://localhost:8000
-        >>> # To stop both servers later:
+        >>>
+        >>> # Start frontend with MCP server
+        >>> server = cognee.start_ui(dummy_callback, start_mcp=True)
+        >>> # UI will be available at http://localhost:3000
+        >>> # MCP server will be available at http://127.0.0.1:8001/sse
+        >>> # To stop all servers later:
         >>> server.terminate()
     """
     logger.info("Starting cognee UI...")
+
+    ports_to_check = [(port, "Frontend UI")]
+
+    if start_backend:
+        ports_to_check.append((backend_port, "Backend API"))
+
+    if start_mcp:
+        ports_to_check.append((mcp_port, "MCP Server"))
+
+    logger.info("Checking port availability...")
+    all_ports_available, unavailable_services = _check_required_ports(ports_to_check)
+
+    if not all_ports_available:
+        error_msg = f"Cannot start cognee UI: The following services have ports already in use: {', '.join(unavailable_services)}"
+        logger.error(error_msg)
+        logger.error("Please stop the conflicting services or change the port configuration.")
+        return None
+
+    logger.info("✓ All required ports are available")
     backend_process = None
 
+    if start_mcp:
+        logger.info("Starting Cognee MCP server with Docker...")
+        cwd = os.getcwd()
+        env_file = os.path.join(cwd, ".env")
+        try:
+            mcp_process = subprocess.Popen(
+                [
+                    "docker",
+                    "run",
+                    "-p",
+                    f"{mcp_port}:8000",
+                    "--rm",
+                    "--env-file",
+                    env_file,
+                    "-e",
+                    "TRANSPORT_MODE=sse",
+                    "cognee/cognee-mcp:main",
+                ],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                preexec_fn=os.setsid if hasattr(os, "setsid") else None,
+            )
+
+            _stream_process_output(mcp_process, "stdout", "[MCP]", "\033[34m")  # Blue
+            _stream_process_output(mcp_process, "stderr", "[MCP]", "\033[34m")  # Blue
+
+            pid_callback(mcp_process.pid)
+            logger.info(f"✓ Cognee MCP server starting on http://127.0.0.1:{mcp_port}/sse")
+        except Exception as e:
+            logger.error(f"Failed to start MCP server with Docker: {str(e)}")
     # Start backend server if requested
     if start_backend:
         logger.info("Starting cognee backend API server...")
@@ -389,16 +543,19 @@ def start_ui(
                     "uvicorn",
                     "cognee.api.client:app",
                     "--host",
-                    backend_host,
+                    "localhost",
                     "--port",
                     str(backend_port),
                 ],
-                # Inherit stdout/stderr from parent process to show logs
-                stdout=None,
-                stderr=None,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
                 preexec_fn=os.setsid if hasattr(os, "setsid") else None,
             )
 
+            # Start threads to stream backend output with prefix
+            _stream_process_output(backend_process, "stdout", "[BACKEND]", "\033[32m")  # Green
+            _stream_process_output(backend_process, "stderr", "[BACKEND]", "\033[32m")  # Green
+
             pid_callback(backend_process.pid)
 
             # Give the backend a moment to start
@@ -408,7 +565,7 @@ def start_ui(
                 logger.error("Backend server failed to start - process exited early")
                 return None
 
-            logger.info(f"✓ Backend API started at http://{backend_host}:{backend_port}")
+            logger.info(f"✓ Backend API started at http://localhost:{backend_port}")
 
         except Exception as e:
             logger.error(f"Failed to start backend server: {str(e)}")
@@ -453,24 +610,38 @@ def start_ui(
 
     # Prepare environment variables
     env = os.environ.copy()
-    env["HOST"] = host
+    env["HOST"] = "localhost"
     env["PORT"] = str(port)
 
     # Start the development server
-    logger.info(f"Starting frontend server at http://{host}:{port}")
+    logger.info(f"Starting frontend server at http://localhost:{port}")
     logger.info("This may take a moment to compile and start...")
 
     try:
         # Create frontend in its own process group for clean termination
-        process = subprocess.Popen(
-            ["npm", "run", "dev"],
-            cwd=frontend_path,
-            env=env,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-            preexec_fn=os.setsid if hasattr(os, "setsid") else None,
-        )
+        # Use shell=True on Windows for npm commands
+        if platform.system() == "Windows":
+            process = subprocess.Popen(
+                ["npm", "run", "dev"],
+                cwd=frontend_path,
+                env=env,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                shell=True,
+            )
+        else:
+            process = subprocess.Popen(
+                ["npm", "run", "dev"],
+                cwd=frontend_path,
+                env=env,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                preexec_fn=os.setsid if hasattr(os, "setsid") else None,
+            )
+
+        # Start threads to stream frontend output with prefix
+        _stream_process_output(process, "stdout", "[FRONTEND]", "\033[33m")  # Yellow
+        _stream_process_output(process, "stderr", "[FRONTEND]", "\033[33m")  # Yellow
 
         pid_callback(process.pid)
 
@@ -479,10 +650,7 @@ def start_ui(
 
         # Check if process is still running
         if process.poll() is not None:
-            stdout, stderr = process.communicate()
-            logger.error("Frontend server failed to start:")
-            logger.error(f"stdout: {stdout}")
-            logger.error(f"stderr: {stderr}")
+            logger.error("Frontend server failed to start - check the logs above for details")
             return None
 
         # Open browser if requested
@@ -491,7 +659,7 @@ def start_ui(
             def open_browser_delayed():
                 time.sleep(5)  # Give Next.js time to fully start
                 try:
-                    webbrowser.open(f"http://{host}:{port}")  # TODO: use dashboard url?
+                    webbrowser.open(f"http://localhost:{port}")
                 except Exception as e:
                     logger.warning(f"Could not open browser automatically: {e}")
 
@@ -499,13 +667,9 @@ def start_ui(
             browser_thread.start()
 
         logger.info("✓ Cognee UI is starting up...")
-        logger.info(f"✓ Open your browser to: http://{host}:{port}")
+        logger.info(f"✓ Open your browser to: http://localhost:{port}")
         logger.info("✓ The UI will be available once Next.js finishes compiling")
 
-        # Store backend process reference in the frontend process for cleanup
-        if backend_process:
-            process._cognee_backend_process = backend_process
-
         return process
 
     except Exception as e:
@@ -523,102 +687,3 @@ def start_ui(
                 except (OSError, ProcessLookupError):
                     pass
         return None
-
-
-def stop_ui(process: subprocess.Popen) -> bool:
-    """
-    Stop a running UI server process and backend process (if started), along with all their children.
-
-    Args:
-        process: The subprocess.Popen object returned by start_ui()
-
-    Returns:
-        bool: True if stopped successfully, False otherwise
-    """
-    if not process:
-        return False
-
-    success = True
-
-    try:
-        # First, stop the backend process if it exists
-        backend_process = getattr(process, "_cognee_backend_process", None)
-        if backend_process:
-            logger.info("Stopping backend server...")
-            try:
-                backend_process.terminate()
-                try:
-                    backend_process.wait(timeout=5)
-                    logger.info("Backend server stopped gracefully")
-                except subprocess.TimeoutExpired:
-                    logger.warning("Backend didn't terminate gracefully, forcing kill")
-                    backend_process.kill()
-                    backend_process.wait()
-                    logger.info("Backend server stopped")
-            except Exception as e:
-                logger.error(f"Error stopping backend server: {str(e)}")
-                success = False
-
-        # Now stop the frontend process
-        logger.info("Stopping frontend server...")
-        # Try to terminate the process group (includes child processes like Next.js)
-        if hasattr(os, "killpg"):
-            try:
-                # Kill the entire process group
-                os.killpg(os.getpgid(process.pid), signal.SIGTERM)
-                logger.debug("Sent SIGTERM to process group")
-            except (OSError, ProcessLookupError):
-                # Fall back to terminating just the main process
-                process.terminate()
-                logger.debug("Terminated main process only")
-        else:
-            process.terminate()
-            logger.debug("Terminated main process (Windows)")
-
-        try:
-            process.wait(timeout=10)
-            logger.info("Frontend server stopped gracefully")
-        except subprocess.TimeoutExpired:
-            logger.warning("Frontend didn't terminate gracefully, forcing kill")
-
-            # Force kill the process group
-            if hasattr(os, "killpg"):
-                try:
-                    os.killpg(os.getpgid(process.pid), signal.SIGKILL)
-                    logger.debug("Sent SIGKILL to process group")
-                except (OSError, ProcessLookupError):
-                    process.kill()
-                    logger.debug("Force killed main process only")
-            else:
-                process.kill()
-                logger.debug("Force killed main process (Windows)")
-
-            process.wait()
-
-        if success:
-            logger.info("UI servers stopped successfully")
-
-        return success
-
-    except Exception as e:
-        logger.error(f"Error stopping UI servers: {str(e)}")
-        return False
-
-
-# Convenience function similar to DuckDB's approach
-def ui() -> Optional[subprocess.Popen]:
-    """
-    Convenient alias for start_ui() with default parameters.
-    Similar to how DuckDB provides simple ui() function.
-    """
-    return start_ui()
-
-
-if __name__ == "__main__":
-    # Test the UI startup
-    server = start_ui()
-    if server:
-        try:
-            input("Press Enter to stop the server...")
-        finally:
-            stop_ui(server)

cognee/api/v1/update/__init__.py

@@ -0,0 +1 @@
+from .update import update

cognee/api/v1/update/routers/__init__.py

@@ -0,0 +1 @@
+from .get_update_router import get_update_router

cognee/api/v1/update/routers/get_update_router.py

@@ -0,0 +1,90 @@
+from fastapi.responses import JSONResponse
+from fastapi import File, UploadFile, Depends, Form
+from typing import Optional
+from fastapi import APIRouter
+from fastapi.encoders import jsonable_encoder
+from typing import List
+from uuid import UUID
+from cognee.shared.logging_utils import get_logger
+from cognee.modules.users.models import User
+from cognee.modules.users.methods import get_authenticated_user
+from cognee.shared.utils import send_telemetry
+from cognee.modules.pipelines.models.PipelineRunInfo import (
+    PipelineRunErrored,
+)
+
+logger = get_logger()
+
+
+def get_update_router() -> APIRouter:
+    router = APIRouter()
+
+    @router.patch("", response_model=None)
+    async def update(
+        data_id: UUID,
+        dataset_id: UUID,
+        data: List[UploadFile] = File(default=None),
+        node_set: Optional[List[str]] = Form(default=[""], example=[""]),
+        user: User = Depends(get_authenticated_user),
+    ):
+        """
+        Update data in a dataset.
+
+        This endpoint updates existing documents in a specified dataset by providing the data_id of the existing document
+        to update and the new document with the changes as the data.
+        The document is updated, analyzed, and the changes are integrated into the knowledge graph.
+
+        ## Request Parameters
+        - **data_id** (UUID): UUID of the document to update in Cognee memory
+        - **data** (List[UploadFile]): List of files to upload.
+        - **datasetId** (Optional[UUID]): UUID of an already existing dataset
+        - **node_set** Optional[list[str]]: List of node identifiers for graph organization and access control.
+                 Used for grouping related data points in the knowledge graph.
+
+        ## Response
+        Returns information about the add operation containing:
+        - Status of the operation
+        - Details about the processed data
+        - Any relevant metadata from the ingestion process
+
+        ## Error Codes
+        - **400 Bad Request**: Neither datasetId nor datasetName provided
+        - **409 Conflict**: Error during add operation
+        - **403 Forbidden**: User doesn't have permission to add to dataset
+
+        ## Notes
+        - To add data to datasets not owned by the user, use dataset_id (when ENABLE_BACKEND_ACCESS_CONTROL is set to True)
+        - datasetId value can only be the UUID of an already existing dataset
+        """
+        send_telemetry(
+            "Update API Endpoint Invoked",
+            user.id,
+            additional_properties={
+                "endpoint": "PATCH /v1/update",
+                "dataset_id": str(dataset_id),
+                "data_id": str(data_id),
+                "node_set": str(node_set),
+            },
+        )
+
+        from cognee.api.v1.update import update as cognee_update
+
+        try:
+            update_run = await cognee_update(
+                data_id=data_id,
+                data=data,
+                dataset_id=dataset_id,
+                user=user,
+                node_set=node_set,
+            )
+
+            # If any cognify run errored return JSONResponse with proper error status code
+            if any(isinstance(v, PipelineRunErrored) for v in update_run.values()):
+                return JSONResponse(status_code=420, content=jsonable_encoder(update_run))
+            return update_run
+
+        except Exception as error:
+            logger.error(f"Error during deletion by data_id: {str(error)}")
+            return JSONResponse(status_code=409, content={"error": str(error)})
+
+    return router