Cognee: Bangun Memory dan Knowledge Graph untuk AI Agent-mu

Halo temen-temen, di tutorial kali ini aku mau ngajak kalian kenalan sama salah satu tools yang menurutku bakal makin penting seiring makin banyaknya orang bikin AI agent, namanya Cognee. Kalau kalian pernah bikin chatbot atau agent pakai LLM, pasti pernah ngerasain masalah klasik: modelnya pinter ngobrol, tapi lupaan. Tiap sesi baru mulai dari nol, gak inget percakapan sebelumnya, gak inget dokumen yang udah kita kasih. Nah, biasanya kita solve ini pakai RAG (Retrieval Augmented Generation) dengan vector database. Tapi vector search doang itu punya keterbatasan: dia cuma nyari yang mirip secara semantik, tapi gak paham hubungan antar informasi.

Di sinilah Cognee masuk. Cognee itu framework open-source yang ngubah dokumen dan percakapan kamu jadi kombinasi knowledge graph plus vector store yang bisa kamu query. Jadi kamu gak cuma dapet potongan teks yang mirip, tapi juga dapet struktur relasi antar entitas. Bayangin aja kayak kamu punya otak kedua buat agent kamu yang bisa nginget fakta sekaligus paham gimana fakta-fakta itu saling terhubung.

Yang bikin aku suka, Cognee ini pakai pendekatan yang mereka sebut ECL: Extract, Cognify, Load. Kamu extract data dari berbagai sumber, cognify (proses jadi graph plus embeddings), terus load ke storage yang bisa di-query. Semuanya jalan di atas asyncio, jadi memang dari sananya udah dirancang buat async Python. Di tutorial ini aku bakal bahas dari instalasi, konfigurasi LLM provider, loop inti add, cognify, search, sampai konsep data points dan ontology, cara pakai buat RAG, dan visualisasi graph-nya. Yuk kita mulai.

Introduction: Apa Itu Cognee dan Kenapa Kamu Perlu

Sebelum masuk kode, aku mau jelasin dulu konsep dasarnya biar kalian gak bingung pas praktek. Cognee itu intinya adalah memory engine buat AI agent. Tapi beda sama sekadar nyimpen chat history di array, Cognee membangun representasi terstruktur dari pengetahuan kamu.

Ada tiga komponen mental yang perlu kamu pahami. Pertama, ada vector store, tempat teks kamu disimpen sebagai embeddings buat pencarian semantik. Kedua, ada graph store, tempat entitas dan relasi antar entitas disimpen sebagai node dan edge. Ketiga, ada relational store, buat metadata dan tracking dokumen. Cognee ngatur ketiga-tiganya secara otomatis buat kamu, jadi kamu gak perlu pusing setup Neo4j, Qdrant, atau Postgres secara manual di awal. Default-nya semua pakai storage lokal yang embedded.

Kenapa graph itu penting? Aku kasih contoh sederhana. Misal kamu ingest dokumen tentang perusahaan. Vector search bisa nemu paragraf yang nyebut "founder" kalau kamu tanya soal pendiri. Tapi kalau kamu tanya "siapa yang kerja di perusahaan yang didirikan oleh si A", vector search bakal kesulitan karena itu butuh nyambungin beberapa fakta. Graph bisa jawab pertanyaan kayak gitu karena relasinya eksplisit tersimpan sebagai edge. Kombinasi keduanya inilah yang bikin retrieval Cognee lebih powerful daripada RAG biasa.

Cognee cocok banget buat kasus kayak agent yang butuh long-term memory, sistem RAG yang butuh reasoning multi-hop, knowledge base internal perusahaan, atau asisten personal yang inget preferensi kamu lintas waktu. Oke, sekarang kita install dulu.

Instalasi

Instalasi Cognee gampang banget, cukup satu perintah pip. Aku saranin kalian bikin virtual environment dulu biar rapi.

python -m venv venv
source venv/bin/activate  # di Windows: venv\Scripts\activate
pip install cognee

Cognee butuh Python 3.10 ke atas ya temen-temen, jadi pastiin versi Python kalian udah cukup baru. Kalian bisa cek dengan:

python --version

Setelah keinstall, langkah paling penting berikutnya adalah konfigurasi LLM provider. Cognee butuh LLM buat dua hal utama: pertama buat extract entitas dan relasi pas proses cognify, kedua buat generate embeddings (kalau kamu pakai embedding dari provider yang sama). Default-nya Cognee pakai OpenAI, jadi cara paling cepet adalah set API key lewat environment variable.

export LLMAPIKEY="sk-your-openai-api-key"

Kalau kamu mau lebih eksplisit atau mau pakai provider lain, Cognee nyediain modul config yang bisa kamu panggil dari Python. Aku lebih suka cara ini karena lebih jelas dan gampang di-track di codebase.

import cognee

Konfigurasi LLM provider
cognee.config.setllmprovider("openai")
cognee.config.setllmmodel("gpt-4o-mini")
cognee.config.setllmapikey("sk-your-openai-api-key")

Kalau kamu pakai provider yang lain, misal model lokal lewat Ollama atau endpoint yang OpenAI-compatible, kamu bisa set juga endpoint-nya. Ini berguna banget kalau kamu mau jalanin semuanya offline atau pakai model self-hosted.

import cognee

cognee.config.setllmprovider("ollama")

cognee.config.setllmmodel("llama3.1:8b")

cognee.config.setllmendpoint("http://localhost:11434/v1")

cognee.config.setllmapikey("ollama")  # placeholder, Ollama gak butuh key beneran

Selain LLM, kamu juga bisa atur di mana data disimpen lewat environment variable atau config. Secara default Cognee bikin folder di direktori sistem buat nyimpen database. Kalau kamu mau kontrol lokasinya, set aja variabel DATAROOTDIRECTORY dan SYSTEMROOTDIRECTORY. Buat awal, gak usah dipikirin dulu, default-nya udah jalan kok. Sekarang kita lanjut ke bagian yang paling seru, yaitu basic usage.

Basic Usage: Loop Inti add, cognify, search

Ini adalah jantung dari Cognee. Ada tiga fungsi yang bakal kamu pakai terus menerus: cognee.add() buat ingest data, cognee.cognify() buat membangun graph, dan cognee.search() buat retrieve. Karena Cognee jalan di atas asyncio, semua fungsi ini adalah coroutine, jadi kamu harus await dan jalanin di dalam event loop. Aku kasih contoh paling minimal dulu biar kalian ngerasain alurnya.

import asyncio
import cognee


async def main():
    # 1. Tambahkan data mentah ke Cognee
    text = """
    Ruby Abdullah adalah seorang AI engineer asal Indonesia.
    Dia mendirikan rubythalib.ai, sebuah platform edukasi AI.
    Platform ini fokus mengajarkan machine learning dan LLM.
    """
    await cognee.add(text)

    # 2. Proses data jadi knowledge graph + embeddings
    await cognee.cognify()

    # 3. Query pengetahuan yang sudah dibangun
    results = await cognee.search("Apa itu rubythalib.ai?")
    for result in results:
        print(result)


if name == "main":
    asyncio.run(main())

Coba kita bedah satu-satu apa yang terjadi. Waktu kamu panggil cognee.add(text), Cognee menyimpan teks mentah itu ke relational store sebagai sebuah dokumen. Di tahap ini belum ada graph, belum ada embedding, cuma disimpen aja sebagai raw data. Kamu bisa panggil add berkali-kali buat nambahin banyak dokumen sebelum cognify.

Nah, keajaiban terjadi di cognee.cognify(). Fungsi ini yang ngambil semua data yang udah kamu add, terus dia jalanin pipeline: memecah teks jadi chunk, manggil LLM buat extract entitas dan relasi, bikin embeddings buat tiap chunk dan entitas, terus nyimpen semuanya ke graph store dan vector store. Proses ini yang paling makan waktu dan makan token LLM, jadi wajar kalau agak lama buat dokumen besar. Setelah cognify selesai, pengetahuan kamu udah terstruktur dan siap di-query.

Terakhir, cognee.search() yang bakal kamu pakai buat nanya. Cognee punya beberapa tipe search yang beda-beda perilakunya, dan ini penting banget buat dipahami. Aku bahas sebentar lagi. Yang jelas, search bakal manfaatin baik graph maupun vector buat ngasih jawaban yang relevan.

Menambahkan Banyak Sumber Data

Kamu gak cuma bisa nambahin string. Cognee bisa nerima list of strings, path ke file, bahkan folder. Ini ngebantu banget kalau kamu punya banyak dokumen.

import asyncio
import cognee


async def ingestmultiple():

    documents = [
        "Python adalah bahasa pemrograman yang populer untuk data science.",
        "PyTorch dan TensorFlow adalah framework deep learning utama.",
        "Hugging Face menyediakan ribuan model pre-trained.",
    ]

    # Tambahkan list dokumen sekaligus
    await cognee.add(documents)

    # Bisa juga tambahkan file dari path
    # await cognee.add("file:///home/rubya/docs/laporan.pdf")

    await cognee.cognify()
    print("Selesai membangun graph!")


if name == "main":
    asyncio.run(ingestmultiple())

Memahami Tipe-Tipe Search

Ini bagian yang sering bikin orang bingung, jadi aku jelasin pelan-pelan. Cognee nyediain beberapa SearchType yang bisa kamu pilih lewat parameter querytype. Masing-masing punya karakter berbeda.

import asyncio
import cognee
from cognee import SearchType


async def searchexamples():
    # GRAPHCOMPLETION: jawaban natural language berbasis graph (mirip RAG)

    answer = await cognee.search(
        "Siapa yang mendirikan rubythalib.ai?",
        querytype=SearchType.GRAPHCOMPLETION,

    )
    print("Graph completion:", answer)

    # RAGCOMPLETION: jawaban berbasis vector chunk klasik
    rag = await cognee.search(
        "Ceritakan tentang platform edukasi AI",
        querytype=SearchType.RAGCOMPLETION,
    )
    print("RAG completion:", rag)

    # CHUNKS: kembalikan potongan teks mentah yang relevan
    chunks = await cognee.search(
        "machine learning",
        querytype=SearchType.CHUNKS,

    )
    print("Chunks:", chunks)

    # INSIGHTS: kembalikan relasi antar entitas dari graph
    insights = await cognee.search(
        "rubythalib.ai",
        querytype=SearchType.INSIGHTS,
    )
    print("Insights:", insights)


if name == "main":
    asyncio.run(searchexamples())

Jadi begini bedanya temen-temen. GRAPHCOMPLETION itu yang paling sering aku pakai kalau mau jawaban natural yang manfaatin struktur graph. Dia bakal ngambil konteks dari graph terus dilempar ke LLM buat disusun jadi jawaban. RAGCOMPLETION mirip tapi konteksnya diambil dari vector chunk aja, jadi ini setara RAG tradisional. CHUNKS ngasih kamu potongan teks mentah tanpa diproses LLM, cocok kalau kamu mau kontrol prompt sendiri. Dan INSIGHTS ini spesial, dia ngasih kamu relasi-relasi dari graph dalam bentuk triplet entitas, cocok buat eksplorasi atau debugging graph kamu.

Advanced Usage: Data Points, Ontology, RAG, dan Visualisasi

Oke sekarang kita naik level. Setelah paham loop dasar, ada beberapa fitur advanced yang bikin Cognee jauh lebih powerful buat use case serius.

Data Points: Ngasih Struktur ke Pengetahuan

Secara default, Cognee bakal otomatis ngextract entitas dari teks kamu. Tapi kadang kamu udah punya data terstruktur dan pengen masukin ke graph dengan skema yang kamu tentuin sendiri. Di sinilah konsep DataPoint masuk. DataPoint itu semacam Pydantic model yang mendefinisikan node di graph kamu, lengkap dengan field dan relasinya.

import asyncio
import cognee
from cognee.lowlevel import DataPoint


class Instructor(DataPoint):
    name: str
    expertise: str
    # metadata memberitahu Cognee field mana yang di-embed
    metadata: dict = {"indexfields": ["name", "expertise"]}



class Course(DataPoint):
    title: str
    description: str
    taughtby: Instructor  # ini jadi relasi (edge) di graph
    metadata: dict = {"indexfields": ["title", "description"]}



async def addstructured():
    ruby = Instructor(
        name="Ruby Abdullah",
        expertise="AI Engineering dan LLM",
    )

    course = Course(
        title="Fundamental LLM untuk Pemula",
        description="Belajar dasar-dasar large language model dari nol.",
        taughtby=ruby,

    )

    # Tambahkan data point langsung ke graph engine
    from cognee.lowlevel import setup
    from cognee.tasks.storage import adddatapoints

    await setup()
    await adddatapoints([course])
    print("Data point terstruktur berhasil ditambahkan!")


if name == "main":
    asyncio.run(addstructured())

Yang keren dari pendekatan ini, karena taughtby bertipe Instructor (yang juga DataPoint), Cognee otomatis bikin edge antara node Course dan node Instructor di graph. Field indexfields di metadata ngasih tau Cognee field mana yang perlu di-embed buat vector search. Jadi kamu dapet kontrol penuh atas struktur graph tanpa ngandelin extraction LLM yang kadang gak konsisten.

Ontology: Ngasih Aturan Domain

Ontology itu semacam cetak biru yang mendefinisikan tipe-tipe entitas dan relasi apa aja yang valid di domain kamu. Kalau kamu punya domain spesifik, misal medis atau hukum, ontology ngebantu Cognee ngextract entitas dengan lebih akurat dan konsisten. Cognee bisa nerima file ontology dalam format OWL/RDF (XML).

import asyncio
import cognee


async def cognifywithontology():

    await cognee.add("Aspirin adalah obat yang digunakan untuk meredakan nyeri.")

    # Arahkan cognify ke file ontology domain kamu
    await cognee.cognify(ontologyfilepath="ontologies/medical.owl")


    results = await cognee.search("Obat apa yang meredakan nyeri?")
    print(results)


if name == "main":
    asyncio.run(cognifywithontology())

Dengan ontology, ekstraksi entitas jadi lebih terarah. Misal Cognee bakal tau bahwa "Aspirin" itu instance dari kelas "Drug" dan bukan sekadar entitas generik. Ini bikin graph kamu lebih rapi dan query jadi lebih presisi. Buat awal kamu gak wajib pakai ontology, tapi begitu domain kamu makin kompleks, ini jadi penyelamat.

Pakai Cognee untuk RAG yang Lebih Pintar

Nah ini use case yang paling banyak dicari. Gimana caranya bikin RAG pipeline pakai Cognee. Kelebihannya dibanding RAG vanila adalah retrieval kamu manfaatin graph, jadi bisa jawab pertanyaan yang butuh nyambungin beberapa fakta. Aku kasih contoh membangun mini knowledge base terus nge-query-nya buat RAG.

import asyncio
import cognee
from cognee import SearchType


async def buildragsystem():

    # Reset dulu biar bersih (opsional, hati-hati di production)
    await cognee.prune.prunedata()
    await cognee.prune.prunesystem(metadata=True)


    knowledge = [
        "rubythalib.ai menawarkan kelas AI Engineering dan Data Science.",
        "Kelas AI Engineering diajar oleh Ruby Abdullah.",
        "Ruby Abdullah memiliki pengalaman membangun sistem LLM produksi.",
        "Data Science mencakup statistik, Python, dan machine learning.",
    ]

    await cognee.add(knowledge)
    await cognee.cognify()

    # Query multi-hop: butuh nyambungin siapa pengajar + pengalamannya
    question = "Apa pengalaman pengajar kelas AI Engineering?"
    answer = await cognee.search(
        question,
        querytype=SearchType.GRAPHCOMPLETION,

    )

    print("Pertanyaan:", question)
    print("Jawaban:", answer)


if name == "main":
    asyncio.run(buildragsystem())

Perhatiin pertanyaannya: "Apa pengalaman pengajar kelas AI Engineering?". Buat jawab ini, sistem harus tau dulu siapa pengajar kelas AI Engineering (Ruby Abdullah), terus nyari pengalaman Ruby Abdullah. Ini dua hop di graph. RAG biasa yang cuma andelin similarity search bakal kesulitan, tapi Cognee bisa handle karena relasinya eksplisit. Ini yang aku maksud graph bikin retrieval lebih pintar.

Satu hal penting, aku pakai cognee.prune.prunedata() dan prunesystem() di awal buat reset. Hati-hati ya, ini ngehapus semua data. Berguna banget pas development biar tiap run mulai bersih, tapi jangan sampe kepanggil di production.

Memisahkan Data dengan Datasets

Kalau kamu punya banyak konteks yang beda, misal data per user atau per project, kamu bisa pisahin pakai dataset. Ini ngebantu isolasi biar retrieval satu user gak nyampur sama user lain.

import asyncio
import cognee


async def usedatasets():
    await cognee.add(
        "Preferensi user A: suka penjelasan detail dengan contoh kode.",
        datasetname="usera",
    )
    await cognee.add(
        "Preferensi user B: suka penjelasan singkat dan to the point.",
        datasetname="userb",
    )

    await cognee.cognify(datasets=["usera", "userb"])

    # Search hanya di dataset tertentu
    results = await cognee.search(
        "Bagaimana preferensi user?",
        datasets=["usera"],

    )
    print(results)


if name == "main":
    asyncio.run(usedatasets())

Visualisasi Knowledge Graph

Ini fitur favorit aku buat debugging. Cognee bisa render knowledge graph kamu jadi file HTML interaktif yang bisa kamu buka di browser. Jadi kamu bisa lihat secara visual node dan edge yang terbentuk, dan mastiin extraction-nya masuk akal.

import asyncio
import cognee


async def visualize():
    await cognee.add(
        "Ruby Abdullah mengajar di rubythalib.ai. "
        "Platform ini mengajarkan machine learning dan LLM."
    )
    await cognee.cognify()

    # Render graph ke file HTML interaktif
    await cognee.visualizegraph("./knowledgegraph.html")
    print("Graph tersimpan di knowledgegraph.html, buka di browser!")



if name == "main":
    asyncio.run(visualize())

Begitu kamu buka knowledgegraph.html, kamu bakal lihat node kayak "Ruby Abdullah", "rubythalib.ai", "machine learning" terhubung dengan edge yang nunjukin relasinya. Percaya deh, lihat graph secara visual itu ngebantu banget buat ngerti kenapa search kamu ngasih hasil tertentu. Kalau ada entitas yang harusnya nyambung tapi ternyata gak, kamu bisa langsung sadar dan perbaiki datanya.

Best Practices

Setelah aku pakai Cognee di beberapa project, ada beberapa hal yang aku pelajarin dan pengen aku bagi ke kalian biar gak kejebak di lubang yang sama.

Pertama, soal biaya dan performa cognify. Ingat bahwa cognify() itu manggil LLM buat tiap chunk, jadi makin banyak data makin banyak token yang kepakai. Buat development, pakai model yang murah kayak gpt-4o-mini dulu. Baru kalau kamu butuh kualitas ekstraksi yang lebih bagus, upgrade ke model yang lebih pinter. Jangan langsung cognify ribuan dokumen pakai model mahal tanpa nyoba di sampel kecil dulu.

Kedua, batch add sebelum cognify. Daripada kamu panggil add terus cognify bolak-balik buat tiap dokumen, mendingan kamu add semua dokumen dulu baru cognify sekali. Ini lebih efisien karena Cognee bisa proses secara batch dan hubungan antar dokumen bisa lebih baik terdeteksi.

Ketiga, pilih SearchType yang tepat. Aku sering lihat orang pakai GRAPHCOMPLETION buat semua hal padahal kadang cukup CHUNKS aja. Kalau kamu cuma butuh potongan teks buat diproses sistem kamu sendiri, CHUNKS lebih cepet dan gak boros token. Pakai GRAPHCOMPLETION cuma kalau kamu emang butuh jawaban natural yang manfaatin reasoning graph.

Keempat, manfaatin DataPoint buat data terstruktur. Kalau kamu udah punya data rapi dari database, jangan ubah dulu jadi teks lepas terus biarin LLM nge-extract ulang. Itu buang-buang token dan hasilnya bisa gak konsisten. Langsung bikin DataPoint dengan skema yang jelas, jadi graph kamu presisi dan deterministik.

Kelima, hati-hati sama async context. Karena semua fungsi Cognee itu coroutine, pastiin kamu selalu jalanin di dalam event loop yang bener. Kalau kamu integrasikan ke framework web kayak FastAPI, kamu bisa langsung await di dalam route handler karena FastAPI udah async. Tapi kalau di script biasa, bungkus di asyncio.run(). Jangan campur kode sync dan async sembarangan karena bisa bikin error yang susah di-debug.

Keenam, buat production, pertimbangkan pakai backend yang proper. Default Cognee pakai storage embedded yang oke buat prototype. Tapi buat production dengan data besar, kamu bisa konfigurasi Cognee pakai vector database beneran kayak Qdrant atau graph database kayak Neo4j. Cognee mendukung ini lewat config, jadi migrasi dari prototype ke production relatif mulus.

import cognee

Contoh konfigurasi backend production
cognee.config.setvectordbprovider("qdrant")

cognee.config.setgraphdbprovider("neo4j")

Ketujuh, monitor dan validasi graph kamu secara berkala. Ekstraksi entitas pakai LLM itu gak selalu sempurna. Sesekali render graph pakai visualizegraph() dan cek apakah entitas dan relasinya masuk akal. Kalau kamu nemu banyak noise atau relasi yang salah, itu sinyal buat kamu memperbaiki kualitas data input atau nambahin ontology.

Kedelapan, kelola API key dengan aman. Jangan hardcode API key kamu di kode kayak contoh-contoh di atas ya, itu cuma buat ilustrasi. Di project beneran, pakai environment variable atau secret manager. Aku biasanya taruh di file .env terus load pakai python-dotenv.

import os
from dotenv import loaddotenv
import cognee

loaddotenv()

cognee.config.setllmapikey(os.getenv("LLMAPIKEY"))

Conclusion

Oke temen-temen, kita udah keliling cukup jauh soal Cognee. Kita mulai dari konsep dasarnya bahwa Cognee itu ngubah dokumen dan percakapan jadi kombinasi knowledge graph plus vector store, terus kita masuk ke loop inti add, cognify, dan search. Kita juga bahas tipe-tipe search yang beda perilakunya, konsep DataPoint buat data terstruktur, ontology buat domain spesifik, cara pakai Cognee buat RAG yang bisa reasoning multi-hop, pemisahan data pakai dataset, sampai visualisasi graph buat debugging.

Yang bikin Cognee menarik menurutku adalah dia ngejembatani gap antara RAG tradisional yang cuma andelin vector similarity dengan kebutuhan reasoning yang lebih kompleks. Dengan graph, agent kamu gak cuma bisa nemu informasi yang mirip, tapi juga bisa nyambungin fakta-fakta yang berhubungan. Ini penting banget kalau kamu bikin agent yang beneran mau kamu andelin buat jawab pertanyaan rumit.

Saran aku, mulai dari yang kecil dulu. Coba loop add, cognify, search yang paling minimal, rasain gimana rasanya, terus render graph-nya biar kamu paham apa yang terjadi di balik layar. Setelah nyaman, baru eksplor DataPoint dan ontology buat kontrol yang lebih presisi. Karena semua jalan di atas asyncio, biasain juga nulis kode async yang rapi dari awal biar gampang diintegrasiin ke aplikasi kamu nanti.

Cognee ini masih terus berkembang dan komunitasnya aktif, jadi worth banget buat kamu pantau. Kalau kamu lagi bangun AI agent yang butuh memory jangka panjang dan reasoning yang lebih dari sekadar keyword matching, Cognee ini layak banget masuk toolkit kamu. Selamat nyoba, dan semoga tutorial ini ngebantu kalian bikin agent yang makin pinter. Sampai ketemu di tutorial berikutnya ya temen-temen!