cognee

1. Project Overview

Note: GitHub anonymous API has triggered rate limit during this round of research, so precise stars/forks/issues has not been written into this note. It is recommended to open GitHub page to review the real-time heat and release status before formal external reference. However, judging from README, official documents, and Docker/CLI/Cloud/SDK instructions, cognee is no longer a demo-only gadget, but is trying to do a complete Agent memory infrastructure.

2. Schematic diagram of the project

2.1 Logo and Demo

! Cognee Logo

! Cognee Demo

2.2 Remember / Recall Working Schematic

! Cognee Remember

! Cognee Recall

2.3 Official Architecture Diagram

! Cognee Architecture

2.4 Demo Video Cover

! Cognee Demo Video

3. What can it mainly do

3.1 provide "long-term memory" to Agent"

Many enterprises will encounter a typical problem when doing Agent: Agent can perform well in one session, but after changing a session, a task and a user, the previous context, preference, experience and business knowledge will be lost. Ordinary RAG can retrieve documents, but it does not necessarily express "who is related to whom", "what an event caused", "what this user preferred in the past" and "which solutions have been successful".

The core value of cognee is to turn these scattered data into long-term memory layers that agents can call:

-Document knowledge can be entered into permanent atlas memory.

-Session preferences can enter the session memory first.

-Session experience can be subsequently bridged to the permanent map via 'improve.

-Multiple Agents can share or call specific data sets under isolation permissions.

Pre-sales speech can be said like this:

ordinary RAG solves the problem of "finding document fragments". cognee pays more attention to "whether Agent can remember, understand relationships, continuously learn and reuse experience in subsequent tasks for a long time".

3.2 Four user-level operations: remember / recall / improve / forget

The user workflow of cognee v1.0 is abstracted into four operations:

This abstraction is very useful for pre-sales, because customers don't need to understand the internal graph/vector details at the beginning, just the four steps of "remember, recall, improve, and forget.

3.3 Vector Retrieval Knowledge Graph Relational Reasoning

The official architecture document clearly states that cognee combines three types of storage:

Ordinary vector RAG is better at "finding similar text". The selling point of cognee is to retain "semantic similarity" and "structural relationship" at the same time: for example, in a customer support scenario, not only a FAQ is found, but also users, work orders, products, historical solutions, invoices, and failed actions can be linked together.

3.4 support permanent memory and conversational memory

The example of the cognee README shows two types of 'memorber ':

await cognee.remember("Cognee turns documents into AI memory.")
await cognee.remember("User prefers detailed explanations.", session_id="chat_1")

The first is permanent knowledge map memory, and the second is session memory. For pre-sales, this is an important distinction:

-Permanent memory: company knowledge base, product documentation, historical cases, expert experience.

-Session memory: a user preference, a task context, and the current session state of an agent.

If customers are concerned about privacy and permissions, they need to further design the isolation method of dataset, user, and agent.

3.5 supports multiple retrieval modes

The CLI documentation mentions that 'recall' supports multiple query types:

Pre-sales advice: Demonstrate the difference between 'GRAPH_COMPLETION and RAG_COMPLETION to the business side; Show 'CHUNKS', 'CYPHER' and provenance to the technical side.

3.6 can run the entire memory layer on the Postgres

There is a very important selling point of production deployment in README: cognee 1.0 can put the entire memory layer into a Postgres instance:

This is very attractive to enterprise customers, because many customers do not want to maintain the Neo4j vector library Redis metadata DB multiple sets of infrastructure in the first place. Starting with Postgres and then replacing Neo4j, Neptune, Redis, Qdrant, Weaviate and other components according to scale is an easier route to land.

3.7 have CLI, local UI, MCP, Cloud and multi-language SDK

cognee is not just a Python package:

-Python SDK: suitable for embedding existing Agent/RAG applications.

-CLI:'cognee-cli remember/recall/improve/forget', suitable for PoC and scripting.

-Local UI:'cognee-cli -ui', which launches the backend and React app.

-Docker API Server: suitable for service.

-MCP Server: suitable for agent tools such as Claude Desktop, Codex, and Cursor.

-Cognee Cloud: Hosting experience.

-Rust client:'cognee-rs '.

-TypeScript client:'@ cognee/cognee-ts'.

-Claude Code plugin / OpenClaw plugin: Precipitates the usage traces and answers of the Agent into memory.

This ecological direction indicates that it wants to be an "Agent memory infrastructure", not just a Python notebook demo.

4. Applicable Scenario

4.1 Enterprise Knowledge Assistant: Upgrade from "Document Question and Answer" to "Corporate Brain"

Suitable for customers:

-Corporate Knowledge Management Team

-Pre-sales/consulting team

-R & D Support Team

-Customer Service Knowledge Base Team

Pain point:

-There are many documents, ordinary RAG can only recall fragments.

-There is a relationship between customer case, product capability, delivery experience, FAQ, work order, but it is not structured.

-After the employee leaves or the project is over, it is difficult to precipitate experience.

Cognee's cut-in:

-Use 'memorber' to access documents, FAQs, cases and meeting minutes.

-Use maps to express the relationship between customers, products, problems and solutions.

-Support business Q & A with 'recall.

-Use 'improve' to precipitate new session experience and feedback.

Pre-sales value:

Upgrade the enterprise knowledge base from "folder search box" to "agent memory layer for sustainable learning".

4.2 Customer Service/After-sales Agent: Avoid Repeated Mistakes

README gives an example of Customer Support Agent: users ask about invoice exceptions and unresolved problems. cognee can track historical interactions, failed actions, resolved cases, product history, and retrieve similar resolved cases.

Customer Value:

-New customer service can reuse historical solutions.

-Agent can see what has happened to this customer in the past.

-For repeated problems, the system can recommend a more confident processing path.

-Processing results can continue to be written back as memory.

PoC can be designed like this:

-Enter 50 historical work orders, 10 FAQs and 5 product change instructions.

-Select 10 real customer service questions.

-Compare whether the answers of ordinary RAG and cognee are more relevant to historical cases.

4.3 SQL Copilot/Expert Experience Reuse

The second example of README is Expert Knowledge Distillation: it precipitates expert SQL, workflow mode, schema structure and successful implementation to help junior analyst reuse expert experience.

This kind of scenario is perfect for pre-sales:

-Customers have senior analysts, but newcomers are slow to get started.

-SQL/BI/data caliber often makes repeated errors.

-Knowledge is not only in documents, but also in historical queries and expert operations.

COGNEE can be used as an "expert experience memory layer", allowing the Agent to find past similar tasks and successful queries based on the current schema, and then adapt to the current problem.

4.4 Developer Agent / Claude Code Memory

The cognee has a Claude Code plugin. The plug-in is captured in the Claude Code lifecycle:

-session start

-user prompt

-tool traces

-assistant response

-Memory protection before context compact

-sync to permanent atlas when end is session

Suitable for customers:

-Internal AI Coding Platform

-R & D knowledge base

-Code Helper memory enhancement

-Multi-project development experience precipitation

Presentation:

Many AI Coding tools have to reinterpret the project context every time. cognee can precipitate project constraints, historical decisions, tool use traces, and answers into a long-term memory that can be recalled.

4.5 Multi-Agent Collaboration Platform

CLI documents include 'agents create/list/register/connections' and other commands. Each agent can have its own agent user and API key, and authorize by dataset.

This is suitable for doing:

-Data isolation for multi-agent platforms.

-Different Agents share corporate knowledge but retain their own conversational memories.

-Agent connection status and memory sources management.

-Multi-tenant knowledge assistant.

5. Not suitable for the scene

6. Core Competence List

7. Architecture/Deployment/Integration

7.1 high-level architecture

7.2 Local PoC Deployment

Minimum installation:

uv pip install cognee

Configure the LLM:

export LLM_API_KEY="YOUR_OPENAI_API_KEY"

Python example:

import cognee
import asyncio

async def main():
    await cognee.remember("Cognee turns documents into AI memory.")
    results = await cognee.recall("What does Cognee do?")
    for result in results:
        print(result)

asyncio.run(main())

CLI example:

cognee-cli remember docs/company-handbook.pdf --dataset-name handbook
cognee-cli recall "Who owns the rollout plan?" --datasets handbook
cognee-cli improve --dataset-name handbook
cognee-cli forget --dataset handbook

7.3 Docker / API / UI

Docker Compose:

cp .env.template .env
docker compose up
docker compose --profile ui up
docker compose --profile mcp up
docker compose --profile postgres up
docker compose --profile neo4j up

Pre-build image:

echo 'LLM_API_KEY="YOUR_OPENAI_API_KEY"' > .env
docker run --env-file ./.env -p 8000:8000 --rm -it cognee/cognee:main
docker run -e TRANSPORT_MODE=http --env-file ./.env -p 8000:8000 --rm -it cognee/cognee-mcp:main

Local UI:

cognee-cli -ui

The UI launches the backend 'http:// localhost:8000 'and the React app 'http:// localhost:3000' and attempts to start the MCP server.

7.4 Postgres production route

Installation:

pip install "cognee[postgres]"

Environment variables:

DB_PROVIDER=postgres
VECTOR_DB_PROVIDER=pgvector
GRAPH_DATABASE_PROVIDER=postgres
CACHE_BACKEND=postgres

DB_HOST=localhost
DB_PORT=5432
DB_USERNAME=cognee
DB_PASSWORD=cognee
DB_NAME=cognee_db

Pre-sales advice: For most enterprise customers, the Postgres route is easier to accept than the introduction of Neo4j Redis vector library at the beginning. After the business scale, graph query complexity and vector scale come up, consider replacing special components.

Key Points of 7.5 Security Configuration

The official security document deserves a pre-sales focus reminder:

This part can be used as a starting point for communication with the customer security team: cognee has a security switch, but it cannot run naked online by default.

8. What can I say before sales

Business-oriented

The biggest problem with many AI assistants nowadays is not that they won't answer, but that they won't remember for a long time. What has been asked, solved and fed back today will be explained again next time. Cognee can deposit enterprise documents, historical work orders, expert experience and conversation preferences into Agent's long-term memory, so that AI assistants not only "check data", but gradually form "company brains".

Business Value:

-Reduce repetitive interpretation background.

-Let newcomers reuse expert experience.

-Let customer service/after-sales Agent refer to historical successful cases.

-Upgrade the enterprise knowledge base from document retrieval to relational memory.

-Support knowledge forgetting, data isolation and subsequent governance.

Technology-oriented

cognee is an agent memory layer that combines relational, vector, and graph storage. It retains chunks and sources, generates embeddings for semantic retrieval, and extracts entity relationships into the graph. The upper layer uses 'remember/recall/improve/forget' to simplify the call, and the lower layer can switch from the local stack of SQLite/LanceDB/Kuzu to the production stack of Postgres/PGVector/Neo4j.

Technical value:

-More structural relationships than unidirectional libraries.

-Easier access to LLM/Agents than traditional knowledge maps.

-Faster PoC than self-developed memory layer.

-CLI, SDK, MCP, Docker are available, and there are many integration paths.

-Apache-2.0 is relatively friendly for business integration.

For management

cognee is suitable for long-term memory PoC as an enterprise AI assistant first, and does not need to build a huge knowledge graph platform at the beginning. We can choose a scenario with clear value, such as customer service history cases, pre-sales database, research and development knowledge base, and use 1-2 weeks to verify whether it can improve the quality of the answer and reduce duplication of labor.

9. Frequently Asked Customer Questions

10. PoC Recommendations

PoC 1: Pre-Sales Data Long-Term Memory Assistant

Input material:

-20 product proposals

-20 customer cases

-10 copies of competition information

-10 historical pre-sales questions and answers

Validation issues:

-What are the common pain points of customers in a certain industry?

-In which cases has a product capability been used?

-What is the difference between a competition and our scheme?

-What concerns were mentioned in a customer's historical communication?

Success Metrics:

-The answer can quote the correct information.

-Ability to link cases, product capabilities and customer issues.

-Relational questions answer more completely than ordinary RAG.

-Support to isolate different customer data by dataset.

PoC 2: Customer Service History Case Memory

Input material:

-100 historical work orders

-FAQ documentation

-Product change records

-Processing results and customer feedback

Validation issues:

-Are there similar historical cases of the current issue?

-Which treatments have failed?

-Which version change could cause this problem?

-What processing path should be recommended for the new job?

Success Metrics:

-Recall accuracy for similar cases.

-The answer can explain the reason for the association.

-Can reduce the time of repeated investigation by customer service.

PoC 3:AI Coding Project Memory

Input material:

-Project Readme

-Architecture Description

-Code specification

-Historical PR/issue summary

-Claude Code/Codex session record

Validation issues:

-What are the architectural constraints of the project?

-Why was a module designed like this before?

-What code styles should new features follow?

-How were similar bugs fixed in the past?

Success Metrics:

-Proactive recall of project context in new sessions.

-Reduce duplication in explaining project background.

-Be able to locate relevant historical decisions.

11. Risks and Considerations

12. My Pre-Sales Judgment

Cognee is one of the most important projects in this batch, because it has hit a very real pain point in the Agent industry: Agent can not only call tools, but also remember, continuously learn and understand enterprise knowledge according to relationships for a long time.

It is suitable for pre-sales positioning is not "another RAG framework",:

Agent long-term memory layer enterprise knowledge mapping memory vector/graph hybrid retrieval infrastructure.

The most suitable for three types of customers:

1. Customers who have done RAG, but found that the response lacks context and relational reasoning.
2. Customers who are working on an enterprise Agent platform and need memory layer.
3. Customers with "experience precipitation" needs such as customer service, pre-sales, research and development, data analysis, etc.

It is not recommended to commit to production to replace the customer's existing knowledge platform. A more stable approach is to use 1-2 high-value scenarios for PoC, especially "historical cases, current problem relationship reasoning. If the cognee is significantly better than the ordinary vector RAG on these issues, it is easy to bring the customer to the "long-term memory/company brain" scenario narrative.

13. REFERENCE

-GitHub-topoteretes/cognee

-Cognee Documentation

-Installation

-Core Concepts Overview

-Architecture

-Cognee CLI

-Security & Privacy

-Cognee Cloud

-Research Paper