cognee

Accepts unstructured data (documents, text, PDFs, web content) via cognee.add() and automatically routes through a configurable preprocessing pipeline that handles format detection, chunking, and normalization before storage. Uses a task-based execution model where each ingestion step (parsing, cleaning, validation) is a discrete pipeline task with telemetry tracking and error recovery, enabling both synchronous and asynchronous processing modes.

Transforms ingested documents into a structured knowledge graph by using LLMs to extract entities, relationships, and semantic triplets (subject-predicate-object) via the cognee.cognify() operation. Implements a multi-stage extraction pipeline: document chunking → entity identification → relationship inference → triplet embedding, with support for custom graph schemas and temporal metadata. The extracted triplets are stored in both a graph database (Neo4j) and vector database simultaneously, enabling both structural and semantic queries.

Captures user feedback on search results, agent decisions, and retrieved context via the cognee.improve() operation, storing feedback as graph entities linked to the original queries and results. Feedback is used to improve ranking, identify knowledge gaps, and retrain extraction models. Implements a feedback loop where agents can learn from corrections and improve future performance. Feedback data is queryable, enabling analysis of system performance and user satisfaction.

Generates interactive visualizations of the knowledge graph using network visualization libraries (Pyvis, D3.js), enabling developers and users to explore entity relationships, identify clusters, and understand graph structure. Implements filtering and search capabilities within the visualization, allowing users to focus on subgraphs of interest. Visualizations can be embedded in web interfaces or exported as static images.

Implements multi-tenant architecture where each tenant has isolated knowledge graphs, vector databases, and access credentials. Uses tenant IDs to partition data at the database level, ensuring queries from one tenant cannot access another tenant's data. Supports role-based access control (RBAC) with configurable permissions (read, write, delete) per tenant and user. Tenant configuration is managed via environment variables or API, enabling easy onboarding of new tenants.

Enables developers to define custom pipeline tasks (cognee/modules/pipelines/tasks/task.py) that can be composed into data processing workflows. Tasks are Python classes that implement a standard interface (execute, validate inputs/outputs) and can be chained together using a pipeline builder. Custom tasks integrate with the telemetry system automatically, enabling observability of custom operations. Supports both synchronous and asynchronous task execution.

Abstracts embedding generation through a provider-agnostic interface supporting multiple embedding models (OpenAI, Hugging Face, local models). Implements caching of embeddings to avoid recomputation, batch processing for efficiency, and automatic fallback to alternative models if primary provider fails. Developers configure embedding provider via environment variables and Cognee automatically routes all embedding operations through the appropriate service.

Provides multiple search strategies accessible via cognee.recall() that intelligently combine graph-based structural queries with vector-based semantic search. Implements a search router that selects optimal retrieval strategy based on query type: graph traversal for relationship-heavy queries, vector search for semantic similarity, and hybrid fusion for complex multi-faceted queries. Results are ranked and deduplicated using configurable scoring functions that weight structural relevance and semantic similarity.

Provides an @agent_memory decorator that automatically captures agent interactions (inputs, outputs, reasoning steps) and persists them to the knowledge graph, enabling agents to build and query their own memory over time. The decorator intercepts function calls, extracts semantic information from execution context, and stores it as graph entities and relationships. Agents can then recall previous interactions via cognee.recall() to inform future decisions, creating a persistent learning loop.

Provides pluggable database adapters (cognee/infrastructure/databases/) that abstract away vendor-specific APIs for both vector databases (Weaviate, Qdrant, Milvus, Pinecone) and graph databases (Neo4j, ArangoDB). Developers configure database backends via environment variables or code, and Cognee automatically routes all storage and retrieval operations through the appropriate adapter. Adapters implement a common interface (store, retrieve, delete, update) enabling seamless switching between providers without code changes.

Abstracts LLM interactions through a provider-agnostic interface (cognee/infrastructure/engine/models/) that supports multiple LLM providers (OpenAI, Anthropic, Ollama, local models) with automatic fallback and error recovery. Implements structured output frameworks (JSON schema validation, Pydantic models) ensuring LLM responses conform to expected formats for downstream processing. Developers configure LLM provider via environment variables and Cognee automatically routes all LLM calls through the appropriate adapter with retry logic and token counting.

Extends the core knowledge graph with temporal metadata (timestamps, version numbers, validity periods) enabling agents to reason about how knowledge evolves over time. Implements time-aware query operations that can retrieve entities and relationships as they existed at specific points in time, track entity evolution across versions, and identify temporal patterns (e.g., 'what changed between date X and Y'). Temporal data is stored as additional properties on graph nodes and edges, enabling both point-in-time and range-based temporal queries.

Exposes Cognee's core capabilities (add, cognify, recall, improve) as Model Context Protocol (MCP) tools that AI agents (Claude, other MCP-compatible clients) can invoke directly. Implements MCP server that translates agent tool calls into Cognee operations, handles async execution, and returns results in MCP-compatible format. Agents can use Cognee as a memory backend without direct Python integration, enabling use cases like Claude agents with persistent knowledge graphs.

Exposes Cognee operations (add, cognify, recall, improve) as HTTP REST endpoints enabling remote access from any HTTP client. Implements async request handling, request validation, and response serialization. Developers can deploy Cognee as a microservice and integrate it into larger systems via standard HTTP calls. API includes endpoints for data ingestion, knowledge graph generation, search, and feedback collection.

Instruments all Cognee operations with OpenTelemetry tracing, enabling developers to observe data flow, identify bottlenecks, and debug issues. Automatically captures traces for pipeline execution, database operations, LLM calls, and search queries. Traces include timing information, error details, and custom attributes (e.g., document size, query complexity). Integrates with standard observability backends (Jaeger, Datadog, New Relic) via OpenTelemetry exporters.