GitHub 트렌딩 딥다이브 · 2026-06-23

cognee 딥다이브
— AI 에이전트에게 "잊지 않는 기억"을 주는 오픈소스 메모리 플랫폼

문서·코드·대화 등 어떤 데이터든 집어넣으면, cognee가 그것을 지식 그래프(서로 연결된 점과 선)벡터 임베딩(의미 좌표)으로 동시에 바꿔, AI가 세션이 바뀌어도 "의미로 검색하고 + 관계로 연결해서" 기억을 꺼내 쓰게 한다. 단순 RAG가 아니라 GraphRAG 기반 메모리 계층이며, remember / recall / forget / improve 네 줄로 다룬다. (저장소: topoteretes/cognee · v1.2.1 · Python · Apache-2.0 · 논문 arXiv:2505.24478 보유 · TrendShift #7)

목차
  1. 프로젝트 한줄 요약
  2. 왜 주목받는가
  3. 기술 스택 전체 지도
  4. 아키텍처 심화 분석 (ECL 파이프라인)
  5. 디렉토리 구조 해부
  6. 학습 포인트 (기술별)
  7. 하드웨어/시스템 요구사항
  8. 직접 해볼 수 있는 실습 과제
  9. 관련 기술 심화 학습 로드맵
  10. 핵심 키워드 사전
  11. 참고 링크

1프로젝트 한줄 요약

"내 데이터를, AI가 평생 기억하고 연결해서 쓰는 두뇌로 바꿔준다."

한 줄로

cognee는 데이터를 '지식 그래프 + 벡터'로 바꿔 AI 에이전트의 장기 기억으로 만들어 주는 오픈소스 라이브러리다.

오늘날 챗봇·에이전트의 가장 큰 약점은 "금붕어 기억력"이다. 대화창을 닫으면 방금 나눈 내용을 잊고, 긴 문서를 주면 일부만 기억한다. cognee는 이 문제를 정면으로 푼다. 문서·PDF·코드·대화 기록 등 아무 데이터나 add()로 넣으면, LLM이 그 안의 개체(사람·회사·개념)와 관계(누가-무엇을-했다)를 뽑아 지식 그래프로 엮고, 동시에 벡터 임베딩으로 의미 좌표를 찍는다. 그 결과 AI는 "비슷한 의미"로도, "연결된 사실"로도 기억을 되살린다.

핵심 용어 두 개부터 풀자. 지식 그래프(knowledge graph)는 정보를 노드(점)엣지(선)로 표현한 지도다. "스티브 잡스—설립—애플"처럼 점과 점을 관계로 잇는다. 벡터 임베딩(vector embedding)은 글의 의미를 숫자 목록(좌표)으로 바꾼 것으로, 좌표가 가까우면 의미가 비슷하다. cognee는 이 둘을 한꺼번에 만들어, "키워드가 안 겹쳐도 의미가 비슷한 것"과 "직접 연결된 사실"을 모두 검색할 수 있게 한다.

용어
AI 메모리 / 메모리 계층 (memory layer)
LLM은 그 자체로는 한 번의 대화(컨텍스트 창) 안에서만 기억한다. 창이 닫히거나 너무 길어지면 잊는다. '메모리 계층'은 LLM 바깥에 두는 영구 저장소로, 필요할 때 관련 기억만 골라 LLM에게 다시 넣어준다(컨텍스트 주입). cognee는 이 저장소를 그래프 + 벡터 DB로 구현한 것.
용어
셀프 호스팅 (self-hosted)
남의 클라우드 서비스에 맡기지 않고 내 서버·내 노트북에서 직접 돌린다는 뜻. cognee는 기본값이 전부 임베디드(파일 기반) DB(SQLite·LanceDB·Kuzu)라, 별도 서버 설치 없이 pip install 하나로 노트북에서 바로 돈다. 데이터가 외부로 안 나가므로 사내 지식·민감 문서에 적합하다.

cognee는 라이브러리(파이썬 패키지)이면서, 동시에 API 서버·MCP 서버·웹 UI로도 띄울 수 있다. 만든 곳은 topoteretes(Vasilije Markovic, Boris Arzentar 등)이고, 단순 오픈소스를 넘어 학술 논문(「지식 그래프와 LLM 인터페이스 최적화」, arXiv:2505.24478)까지 낸, 이론적 배경이 있는 프로젝트다.

2왜 주목받는가

"벡터만 쓰는 평범한 RAG의 한계를, 그래프를 더해 넘어선다."

2024~2026년 AI 앱의 표준 기억법은 RAG(검색 증강 생성)였다. 문서를 잘게 잘라 벡터로 만들고, 질문과 의미가 가까운 조각을 찾아 LLM에 붙여 준다. 강력하지만 약점이 뚜렷하다 — "조각들 사이의 관계"를 모른다. "A가 B의 상사이고, B가 C 프로젝트를 망쳤다"는 연결된 추론은, 흩어진 텍스트 조각만으로는 잘 안 된다.

기존 방식(벡터-only RAG)의 함정
"비슷한 문장은 잘 찾지만, '연결된 사실'은 놓친다"

벡터 검색은 유사도(닮음)만 본다. 그래서 "이 환자의 약 A와 약 B를 같이 먹으면 위험한가?"처럼 여러 조각을 이어붙여야 답이 나오는 질문(multi-hop)에 약하다. 또 같은 사람이 문서마다 다르게 등장하면 동일 인물로 묶지 못해 기억이 파편화된다. 결국 "검색은 되는데 추론이 안 되는" 반쪽짜리 기억이 된다.

cognee의 해결
벡터(의미) + 그래프(관계)를 한 파이프라인에서 같이 만든다 = GraphRAG

cognee는 데이터를 넣을 때 벡터 임베딩과 지식 그래프를 동시에 생성한다. 검색 시 의미가 가까운 것(벡터)과 관계로 이어진 것(그래프)을 함께 가져와, multi-hop 추론과 개체 통합(같은 사람 묶기)을 해낸다. 게다가 온톨로지(개념 분류 체계)로 그래프를 정돈해, 막 자란 잡초 그래프가 아니라 의미가 정렬된 그래프를 만든다.

트렌딩을 끌어올린 결정적 변화는 "메모리 플랫폼"으로의 재포지셔닝이다. 초기 cognee는 "GraphRAG 라이브러리"였지만, 지금은 에이전트의 장기 기억 인프라를 표방한다. 특히 Claude Code 플러그인으로 코딩 에이전트의 세션 기억을 자동 저장/주입하고, remember / recall / forget / improve라는 사람이 외우기 쉬운 4개 동사 API를 전면에 내세워 진입 장벽을 확 낮췄다.

비유

벡터-only RAG = 형광펜만 그은 책 — "이 문장 어디서 봤더라" 비슷한 페이지는 찾지만, 사건의 인과·인물 관계도는 머릿속에 없다.
cognee = 형광펜 + 등장인물 관계도 + 사건 연표를 같이 만든 독서 노트 — 비슷한 대목도 찾고, "누가 누구와 왜 엮였는지"도 한눈에 따라간다.

경쟁/대안과 무엇이 다른가

구분순수 벡터 RAG
(LangChain 등)
Mem0 / Zep
(에이전트 메모리)
cognee
저장 방식벡터만주로 벡터+요약그래프 + 벡터 동시
multi-hop 추론약함제한적그래프 순회로 강함
온톨로지(의미 정렬)없음제한적내장(RDF 기반)
실행 위치대개 로컬SaaS 위주셀프호스팅 기본
이관(마이그레이션)--Mem0·Zep·Letta에서 가져오기
라이선스오픈소스혼합Apache-2.0

물론 대가도 있다. 데이터를 넣을 때 LLM으로 개체·관계를 뽑는 단계(cognify)가 들어가, 순수 벡터 RAG보다 인덱싱이 느리고 LLM 호출 비용이 든다. 즉 cognee의 매력은 "가장 빠르고 싼 검색"이 아니라, "관계까지 기억하는, 추론 가능한 메모리"다. 빠른 1회성 검색이면 평범한 RAG가 낫고, 누적되는 지식·에이전트 장기 기억이면 cognee가 빛난다.

3기술 스택 전체 지도

100% 파이썬. 핵심은 'LLM 추상화 + 갈아끼우는 DB 어댑터 + 비동기 파이프라인'.

cognee는 Voicebox 같은 데스크탑 앱과 달리 순수 파이썬 라이브러리(Python 3.10~3.14)다. 그래서 "프론트엔드/백엔드/인프라"보다 ① LLM 레이어 ② 저장소(DB) 레이어 ③ 파이프라인/서빙 레이어 세 축으로 보는 게 머리에 잘 들어온다. 가장 큰 설계 미덕은 모든 외부 의존성을 '갈아끼울 수 있는 어댑터'로 추상화했다는 점이다.

① LLM·임베딩 레이어 — "어떤 모델이든 꽂는다"

cognee는 특정 LLM에 묶이지 않는다. litellm이라는 통합 클라이언트로 OpenAI·Anthropic·Ollama(로컬)·Mistral·Groq 등 수십 개 공급자를 같은 코드로 부른다. 그리고 instructor로 LLM의 자유로운 텍스트 응답을 구조화된 데이터(Pydantic 객체)로 강제한다 — 지식 그래프를 뽑으려면 "사람·관계"가 정해진 형식으로 나와야 하기 때문이다.

역할라이브러리
LLM 통합 호출litellm >=1.83 — 공급자 무관 단일 인터페이스(OpenAI/Anthropic/Ollama/Groq/Mistral…)
구조화 출력 강제instructor + pydantic 2 — LLM 답을 스키마(개체·엣지)로 검증
토큰 계산tiktoken — 청크 크기·컨텍스트 한도 관리
기본 임베딩OpenAI 임베딩(기본) · 로컬 임베딩으로 교체 가능
용어
instructor & 구조화 출력(structured output)
LLM에게 "JSON 형식으로만 답해"라고 부탁해도 형식이 깨질 때가 많다. instructor는 Pydantic 모델을 주면 LLM 응답을 그 모델대로 파싱·검증하고, 틀리면 자동 재시도한다. cognee가 "엔티티: 이름·타입, 엣지: 출발-관계-도착"을 안정적으로 뽑는 비결.

② 저장소(DB) 레이어 — 세 종류 DB를 동시에

cognee의 진짜 독특함은 여기 있다. 보통 앱은 DB 하나를 쓰지만, cognee는 관계형 + 벡터 + 그래프 세 종류를 함께 쓴다. 각각 어댑터 패턴으로 추상화돼, 환경변수만 바꾸면 로컬 임베디드 ↔ 운영용 서버로 갈아끼운다.

DB 종류역할기본값(로컬)운영용 교체 옵션
관계형(Relational)데이터셋·사용자·메타데이터·작업 기록SQLitePostgreSQL (SQLAlchemy 2 + Alembic)
벡터(Vector)의미 임베딩 저장·유사도 검색LanceDB(파일형)pgvector 등
그래프(Graph)개체·관계(노드·엣지) 저장·순회Kuzu(임베디드)Neo4j · Amazon Neptune · Postgres
비유

세 DB = 도서관의 세 가지 색인. 관계형 DB는 대출 장부(누가 무슨 데이터셋을 언제 넣었나), 벡터 DB는 '비슷한 책' 추천 색인(의미가 가까운 것), 그래프 DB는 '인용·연결' 관계도(어느 책이 어느 책과 엮였나). cognee는 질문 하나에 이 세 색인을 함께 들춰 답한다.

③ 파이프라인·서빙 레이어 — 비동기로 굴러가는 ETL

데이터를 기억으로 바꾸는 과정은 여러 단계의 비동기 작업(Task) 사슬이다(다음 절에서 자세히). 이걸 API로도 열 수 있게 FastAPI 서버, MCP 서버, Next.js 프론트엔드가 함께 들어 있다.

레이어핵심 라이브러리
API 서버fastapi · uvicorn · gunicorn · fastapi-users(인증·멀티테넌시)
그래프 연산networkx(그래프 알고리즘) · rdflib(온톨로지/RDF)
비동기 I/Oasyncio · aiohttp · aiosqlite · aiofiles
안정성tenacity(재시도) · structlog(로깅) · filelock(교차 프로세스 잠금)
분산 실행modal(서버리스 워커) — distributed/에서 대규모 인제스트
문서 로더pypdf · filetype · 선택적 스크래핑(beautifulsoup4 · Tavily)

4아키텍처 심화 분석 — ECL 파이프라인

cognee의 심장은 'Extract → Cognify → Load' 라는, 데이터를 기억으로 굽는 3단계 가마다.

cognee의 동작은 두 줄의 핵심 함수로 요약된다. cognee.add(데이터)로 원본을 받아 적재(ingest)하고, cognee.cognify()로 그걸 지식 그래프 + 벡터로 굽는다. 이 cognify가 cognee를 cognee이게 하는 부분으로, 내부적으로 ECL(Extract–Cognify–Load) 파이프라인을 돈다. 실제 소스(cognify.py)의 기본 작업 사슬은 다음과 같다.

┌──────────────────────────────────────────────────────────────────┐ │ cognee.add("문서/PDF/코드/대화…") → 원본을 데이터셋에 적재 │ │ (SQLite 메타데이터 + 원본 파일 저장 + 중복 해시 체크) │ └───────────────────────────────┬──────────────────────────────────┘ │ cognee.cognify() ▼ ════════════ ECL 파이프라인 (비동기 Task 사슬) ════════════ │ [E] ① classify_documents 원본 → 타입별 Document 객체로 분류 │ (PDF / 텍스트 / 코드 / 이미지…) ▼ [E] ② extract_chunks Document → 의미 단위 '청크'로 분할 │ (TextChunker, 토큰 한도 기준) ▼ [C] ③ extract_graph_and_summarize ★핵심★ │ • LLM이 청크에서 엔티티·관계 추출 → KnowledgeGraph │ • 동시에 각 청크를 요약(검색용) │ • instructor로 구조(스키마) 강제 + 온톨로지로 정렬 ▼ [L] ④ add_data_points 노드·엣지·임베딩을 실제 DB에 저장 │ • 그래프 DB(Kuzu/Neo4j)에 노드/엣지 │ • 벡터 DB(LanceDB/pgvector)에 임베딩 │ • DataPoint의 identity_fields로 같은 개체 자동 병합(dedup) ▼ [L] ⑤ extract_dlt_fk_edges 구조화 데이터의 외래키 관계까지 엣지로 │ ▼ ════════════════════════════════════════════════════════════ │ cognee.search(질의, SearchType) ▼ 벡터 검색(의미) + 그래프 순회(관계)를 함께 → LLM에 컨텍스트 주입 → 답
용어
ECL = Extract · Cognify · Load (cognee판 ETL)
데이터 엔지니어링의 고전 ETL(Extract–Transform–Load)을 AI 메모리용으로 변주한 것. 평범한 ETL의 'Transform'(단순 변환) 자리에, cognee는 'Cognify'(LLM으로 의미·관계를 인지화)를 넣었다. 즉 "추출 → 인지화 → 적재". 이름 그대로 데이터를 '인지(cognition) 가능한 형태'로 바꾸는 게 목표.

핵심 설계 패턴 1 — Task 파이프라인 (조립식 사슬)

위 ①~⑤는 모두 Task(함수, 설정...) 객체로, 리스트에 담긴 작업 사슬이다. run_pipeline이 이 리스트를 순서대로 비동기 실행하며 청크를 배치(batch) 단위로 흘려보낸다. 덕분에 사용자는 기본 사슬을 그대로 쓰거나, 중간 Task를 갈아끼워 '나만의 cognify'를 만들 수 있다(예: 시간정보 추출용 temporal_tasks 사슬이 따로 존재).

# cognify.py의 기본 작업 사슬 (요지)
default_tasks = [
    Task(classify_documents),                 # E: 타입 분류
    Task(extract_chunks_from_documents, ...), # E: 청크 분할
    Task(extract_graph_and_summarize, ...),   # C: 그래프+요약 (LLM)
    Task(add_data_points, ...),               # L: DB 저장
    Task(extract_dlt_fk_edges),               # L: 외래키 엣지
]
# run_pipeline이 이 리스트를 batch로 비동기 실행

핵심 설계 패턴 2 — DataPoint (모든 노드의 공통 DNA)

그래프에 들어가는 모든 노드는 DataPoint라는 Pydantic 모델을 상속한다. 여기에 cognee의 영리한 한 수가 있다 — identity_fields. 기본 ID는 랜덤(UUID)이라 실행할 때마다 다른 노드가 되지만, "이름" 같은 정체성 필드를 지정하면 그 값으로 ID를 결정론적으로 계산한다. 그래서 "스티브 잡스"가 문서 10곳에 나와도 전부 같은 노드 하나로 병합된다(개체 통합·중복 제거).

DataPoint 필드의미
id노드 식별자. identity_fields 지정 시 값으로부터 결정론적 생성 → 자동 병합
metadata.index_fields어떤 필드를 임베딩(벡터화)할지 지정 — 의미 검색 대상
version · updated_at버전·갱신 시각 → 기억이 시간에 따라 진화
ontology_valid온톨로지(개념 체계)에 부합하는지 표시
topological_rank그래프 내 위상 순위 — 중요 노드 가중에 활용

핵심 설계 패턴 3 — 검색 전략(SearchType)을 골라 쓴다

같은 그래프라도 질문 성격에 맞는 검색 방식이 다르다. cognee는 search(질의, query_type=SearchType.XXX)로 전략을 고른다. 대표적인 것만:

SearchType무엇을 하나
GRAPH_COMPLETION그래프 관계를 따라가며 답 생성 — cognee의 간판(multi-hop)
RAG_COMPLETION전통적 벡터 RAG 방식(비교/호환용)
CHUNKS / SUMMARIES원청크/요약을 그대로 반환
CYPHER / NATURAL_LANGUAGE그래프 질의어(Cypher)·자연어로 그래프 질의
TEMPORAL시간정보 기반 검색(언제 무슨 일이)
FEELING_LUCKY질문을 보고 최적 전략을 자동 선택(recall이 내부적으로 활용)

마지막으로, 사용자가 마주하는 2계층 API를 정리하자. V1(저수준)add / cognify / search / prune처럼 파이프라인을 직접 다루고, V2(메모리 지향)remember / recall / forget / improve로 추상화했다. remember()는 내부적으로 add + cognify + improve를 묶어 실행하는 식이다 — 초보자는 V2 4동사부터, 깊이 파면 V1 파이프라인으로 내려가면 된다.

5디렉토리 구조 해부

레포는 '라이브러리 본체(cognee/) + 서버·UI·분산'의 모노레포다.

저장소 최상위는 크게 ① 라이브러리 본체(cognee/) ② MCP 서버(cognee-mcp/) ③ 프론트엔드(cognee-frontend/) ④ 분산 실행(distributed/) ⑤ 예제·평가로 나뉜다. 핵심은 cognee/ 안의 3분할 구조다 — api(겉으로 드러난 명령), modules(도메인 로직), tasks(파이프라인 한 칸 한 칸), 그리고 그 아래를 받치는 infrastructure(DB·LLM 어댑터).

cognee/ ← 저장소 루트 (모노레포) ├── cognee/ ★ 라이브러리 본체 (pip install cognee) │ ├── api/v1/ 겉 명령: add, cognify, search, remember, │ │ recall, forget, improve, prune, datasets… │ ├── modules/ 도메인 로직 (가장 큰 폴더) │ │ ├── cognify/ cognify 설정·롤백 │ │ ├── chunking/ 청크 분할기(Text/Csv/Langchain…) │ │ ├── graph/ 그래프 구성·연산 │ │ ├── ontology/ 온톨로지(개념 체계) 생성·정렬 │ │ ├── retrieval/ 검색 전략 구현 │ │ ├── search/ SearchType 정의·라우팅 │ │ ├── pipelines/ Task 실행 엔진(run_pipeline) │ │ ├── users/ 멀티테넌시·권한 │ │ └── sync/ · cloud/ 클라우드 동기화 │ ├── tasks/ ★ 파이프라인 작업 단위(ECL 각 칸) │ │ ├── documents/ 분류·청크 추출 │ │ ├── graph/ 그래프+요약 추출 │ │ ├── storage/ add_data_points (DB 적재) │ │ ├── temporal_graph/ 시간 인지(이벤트·타임스탬프) │ │ ├── summarization/ 요약 │ │ └── ingestion/ 데이터 수집·외래키 엣지 │ ├── infrastructure/ ★ 외부 의존 어댑터 (갈아끼우는 부분) │ │ ├── databases/ │ │ │ ├── relational/ SQLite·Postgres (SQLAlchemy) │ │ │ ├── vector/ LanceDB·pgvector │ │ │ └── graph/ Kuzu·Neo4j·Neptune·Postgres │ │ ├── llm/ litellm 래퍼·프롬프트 │ │ └── engine/models/ DataPoint(노드 공통 모델) │ ├── cli/ cognee-cli (remember/recall/forget/-ui) │ └── eval_framework/ 벤치마크·평가 도구 ├── cognee-mcp/ MCP 서버 (Claude/Cursor/VS Code 연동) ├── cognee-frontend/ Next.js 웹 UI (그래프 시각화) ├── cognee-starter-kit/ 입문용 템플릿 ├── distributed/ Modal 서버리스 분산 워커 ├── examples/ · notebooks/ 예제·주피터 노트북 ├── Dockerfile · docker-compose.yml 컨테이너 배포(프로필: ui/mcp/postgres/neo4j) └── pyproject.toml 의존성·extras 정의(uv/poetry)
비유

이 구조는 레스토랑 주방과 같다. api메뉴판(손님이 주문하는 이름), tasks조리 공정 한 칸 한 칸(썰기·볶기·플레이팅), modules요리 레시피, infrastructure가스·수도·냉장고(어느 브랜드든 갈아끼우는 설비). 메뉴판만 봐도 쓸 수 있고, 주방 깊숙이 들어가면 공정을 뜯어고칠 수 있다.

6학습 포인트 (기술별)

cognee 한 레포에 'AI 메모리 시스템'을 짓는 데 필요한 거의 모든 조각이 들어 있다.

① GraphRAG — 검색의 다음 단계

벡터 RAG만 알던 사람에게 cognee는 "왜 그래프를 더하는가"의 살아 있는 교과서다. tasks/graph/modules/retrieval/를 읽으면, LLM으로 관계를 뽑아 그래프를 만들고 그걸 순회해 답하는 흐름이 보인다.

실습 아이디어

같은 문서를 RAG_COMPLETIONGRAPH_COMPLETION으로 각각 검색해 답 품질을 비교해 보라. "A와 B의 관계는?" 같은 multi-hop 질문에서 차이가 극명하게 드러난다.

② 어댑터 패턴 — 의존성 갈아끼우기

infrastructure/databases/인터페이스(추상) + 구현(어댑터) 분리의 모범 사례다. vector_db_interface.py라는 약속을 정해두고, LanceDB·pgvector가 각자 구현한다. 새 벡터 DB를 붙이고 싶으면 인터페이스만 채우면 된다 — OCP(개방-폐쇄 원칙)의 실전.

실습 아이디어

vector_db_interface.py를 읽고 메서드 목록을 적은 뒤, "내가 Chroma 어댑터를 만든다면 어떤 함수를 구현해야 하나"를 표로 그려 보라.

③ LLM 구조화 출력 — instructor 패턴

"LLM이 JSON을 깨뜨린다"는 흔한 고통을 cognee는 instructor + Pydantic으로 푼다. tasks/graph/에서 KnowledgeGraph 스키마를 정의하고 LLM 출력을 그 틀에 맞춰 검증·재시도하는 코드를 보면, 프로덕션에서 LLM을 다루는 정석을 배운다.

실습 아이디어

간단한 Pydantic 모델(예: Person(name, age, role))을 만들고 instructor로 자기소개 문장에서 추출해 보라. 잘못된 출력이 어떻게 자동 교정되는지 관찰.

④ 비동기 파이프라인 — asyncio 배치 처리

modules/pipelines/run_pipelineTask 리스트를 비동기로, 배치 단위로 흘려보낸다. 수백~수천 청크를 LLM에 보낼 때 동시성으로 처리량을 끌어올리는 패턴(세마포어·배치)을 학습하기 좋다.

⑤ MCP 서버 — 에이전트에 도구 열어주기

cognee-mcp/@mcp.toolcognify_file·search·list_datasets·visualize_graph_ui 등을 노출한다. "내 라이브러리를 AI 에이전트의 도구로 만드는 법"의 깔끔한 예제다.

실습 아이디어

cognee MCP 서버를 띄워 Claude Desktop/Cursor에 연결하고, "이 PDF 기억해줘 → 방금 뭐였지?"를 에이전트가 도구로 처리하게 해 보라.

⑥ 멀티테넌시·권한 — fastapi-users

modules/users/는 사용자·테넌트별로 데이터를 격리한다. "여러 사용자가 한 메모리 서버를 공유하되 서로 못 보게" 만드는 SaaS형 권한 설계를 엿볼 수 있다.

7하드웨어/시스템 요구사항

기본은 노트북에서도 충분 — 부담은 'GPU'가 아니라 'LLM API 비용'이다.

cognee는 Voicebox처럼 거대한 로컬 모델을 돌리는 앱이 아니다. 무거운 추론(개체·관계 추출)은 외부 LLM(예: OpenAI)에 위임하므로, 내 컴퓨터의 부담은 가볍다. 진짜 비용은 LLM API 호출(토큰) 요금이다.

항목최소/기본비고
Python3.10 ~ 3.14순수 파이썬 라이브러리
설치pip / uv / poetry install cognee기본 DB가 전부 임베디드라 서버 불필요
RAM4~8GB로 시작 가능대량 인제스트·로컬 임베딩 시 더 필요
GPU불필요(기본)로컬 LLM(Ollama)·로컬 임베딩 쓸 때만 권장
필수 키LLM_API_KEYOpenAI 등. Ollama로 완전 로컬화도 가능
Docker(선택)compose 프로필API:8000 · MCP:8001 · UI:3000 · Neo4j · Postgres
초보자가 놓치는 함정
"설치는 가벼운데, 큰 데이터를 cognify하면 API 요금이 훅 나간다"

cognify는 청크마다 LLM을 부른다. 수백 페이지 문서를 한 번에 굽으면 토큰 비용이 누적된다. 처음엔 작은 문서 한두 개로 흐름을 익히고, 비용이 걱정되면 저렴한 모델·로컬 Ollama로 바꾸거나 청크 배치 크기를 조절하자. 운영 규모에선 Postgres·Neo4j로 DB를 올리고 distributed/(Modal)로 분산 처리한다.

8직접 해볼 수 있는 실습 과제

"설치 5분 → 기억 만들기 → 그래프 눈으로 보기 → 내 파이프라인"으로 난이도 상승.

과제 1. 5줄로 첫 기억 만들기 난이도 ★☆☆☆☆

가상환경을 만들고 pip install cogneeLLM_API_KEY 설정 → 아래를 실행한다. cognee의 V2 4동사를 몸으로 익히는 단계.

import cognee, asyncio

async def main():
    await cognee.remember("cognee는 문서를 AI 메모리로 바꾼다.")
    results = await cognee.recall("cognee가 뭐 하는 거야?")
    for r in results: print(r)

asyncio.run(main())

과제 2. 내 PDF를 지식 그래프로 굽기 난이도 ★★☆☆☆

cognee.add("./내문서.pdf")cognee.cognify()cognee.search(...) 흐름을 직접 돌려 본다. 작은 PDF(5~10쪽)로 시작해 "이 문서의 핵심 인물/개념의 관계"를 물어보라.

과제 3. RAG vs GraphRAG 비교 실험 난이도 ★★★☆☆

같은 데이터에 대해 SearchType.RAG_COMPLETIONSearchType.GRAPH_COMPLETION 결과를 나란히 출력한다. multi-hop 질문("X가 속한 팀의 리더가 진행한 다른 프로젝트는?")에서 어느 쪽이 이기는지 표로 정리 — cognee의 존재 이유를 스스로 증명하는 과제.

과제 4. 그래프를 눈으로 보고 CLI/UI 띄우기 난이도 ★★★☆☆

cognee.visualize_graph()로 그래프를 그리거나, cognee-cli -ui로 로컬 UI를 띄워 노드·엣지를 시각적으로 탐색한다. "내 문서가 어떤 모양의 지식 그래프가 됐는지" 직접 보는 경험이 핵심.

과제 5. 나만의 cognify 파이프라인 / 에이전트 연동 난이도 ★★★★★

get_default_tasks()를 참고해 Task 하나를 추가·교체한 커스텀 파이프라인을 만들어 본다(예: 번역 Task 삽입, 또는 temporal 사슬 사용). 더 나아가 cognee MCP 서버를 Claude Code/Cursor에 붙여, 코딩 세션 기억이 자동 저장·주입되는 환경을 구성한다.

9관련 기술 심화 학습 로드맵

'임베딩 → 벡터 RAG → 지식 그래프 → GraphRAG → 에이전트 메모리'의 4주 코스.

주차주제학습 내용 & cognee 연결
1주차임베딩 & 벡터 검색 기초임베딩이 뭔지, 코사인 유사도, 벡터 DB(LanceDB) 기본. cognee의 infrastructure/databases/vector/를 열어 어댑터 구조 확인.
2주차RAG 파이프라인청킹·검색·컨텍스트 주입의 전 과정. cognee의 tasks/documents/(청크)와 RAG_COMPLETION 전략을 읽고 직접 RAG를 한 번 짜 본다.
3주차지식 그래프 & 온톨로지노드/엣지, Cypher 질의(Neo4j), RDF/온톨로지. cognee의 modules/ontology/tasks/graph/로 "텍스트→그래프" 추출을 학습.
4주차GraphRAG & 에이전트 메모리벡터+그래프 결합 검색, multi-hop 추론, 에이전트 장기 기억. cognee 논문(arXiv:2505.24478)을 읽고 remember/recall/improve를 실제 에이전트에 통합.
학습 팁
"논문 → 코드 → 실습"의 삼각 독해

cognee는 드물게 논문이 있는 오픈소스다. 1) 논문에서 "왜 그래프가 LLM 추론을 돕는가"의 이론을 잡고 → 2) cognify.py의 Task 사슬에서 이론이 코드로 어떻게 구현됐는지 대조하고 → 3) 과제 3(RAG vs GraphRAG)으로 직접 효과를 측정하면, 검색·메모리 분야의 큰 그림이 한 번에 잡힌다.

10핵심 키워드 사전

cognee 문서·코드에서 반복되는 용어를 한 곳에.

용어
GraphRAG
벡터 검색(의미 유사도)에 지식 그래프 순회(관계 추적)를 결합한 검색·생성 기법. 흩어진 조각만 보는 일반 RAG와 달리 multi-hop 추론이 가능. cognee의 핵심 정체성.
용어
cognify
cognee의 동사이자 함수명. 적재된 원본 데이터를 LLM으로 개체·관계를 뽑아 지식 그래프 + 벡터로 '굽는' 핵심 단계. ETL의 Transform 자리에 'Cognify(인지화)'를 넣은 것.
용어
DataPoint
그래프의 모든 노드가 상속하는 Pydantic 모델. identity_fields로 ID를 값에서 결정론적으로 만들어, 같은 개체가 여러 번 나와도 하나로 병합(dedup)한다.
용어
온톨로지 (ontology)
개념과 그 관계를 정의한 '분류 체계 설계도'. "사람은 회사에 고용된다" 같은 규칙을 미리 두면, 추출된 그래프가 제멋대로 자라지 않고 의미적으로 정렬된다. cognee는 RDF(rdflib) 기반으로 다룬다.
용어
MCP (Model Context Protocol)
AI 에이전트가 외부 도구·데이터에 접근하는 표준 규약. cognee는 MCP 서버를 제공해 Claude·Cursor·VS Code가 "기억하기/검색하기"를 도구처럼 호출하게 한다.
용어
litellm
OpenAI·Anthropic·Ollama·Groq 등 수십 개 LLM 공급자를 하나의 인터페이스로 부르게 해주는 라이브러리. cognee가 특정 모델에 종속되지 않는 비결.
용어
어댑터 패턴 (adapter pattern)
"약속(인터페이스)"을 정해두고 구체 구현(LanceDB·Neo4j…)을 갈아끼우는 설계. cognee가 로컬↔운영 DB를 환경변수만으로 전환하는 토대.
용어
multi-hop 추론
"A→B→C"처럼 여러 사실을 연쇄로 이어야 답이 나오는 추론. 벡터-only RAG의 약점이자, 그래프를 가진 cognee의 강점.

11참고 링크

공식 저장소·문서·논문·커뮤니티.

GitHub 저장소 · github.com/topoteretes/cognee — 본체 소스. cognee/ · cognee-mcp/ · examples/부터 보면 좋다.

공식 문서 · docs.cognee.ai — 설치·LLM 공급자 설정·검색 전략 가이드.

연구 논문 · arXiv:2505.24478 — "Optimizing the Interface Between Knowledge Graphs and LLMs for Complex Reasoning"(Markovic et al., 2025).

한국어 README · README_ko.md — 저장소에 한국어 안내가 기본 포함.

커뮤니티 · r/AIMemory · Discord · 커뮤니티 플러그인 cognee-community

Claude Code 연동 · cognee-integrations / claude-code — 세션 기억 자동 저장·주입 플러그인.

TrendShift · trendshift.io/repositories/13955