Self-Hosting Cognee: Välj LLM på Ollama

Testa Cognee med lokala LLMs - verkliga resultat

Sidinnehåll

Cognee är en Pythonramverk för att bygga kunskapsgrafer från dokument med hjälp av LLMs. Men fungerar det med självvärdbaserade modeller?

Jag testade det med flera lokala LLMs för att hitta ut.

cognee processing pdf with procelist

Det är en prislistepdf-sida som jag har försökt bearbeta.

TL;DR

Cognee fungerar troligen bra med smarta LLMs med hundratals miljarder parametrar, men för självvärdbaserade RAG-konfigurationer som förväntas automatiskt extrahera data från PDF-filer (som prislistor), så misslyckades det att leverera på min hårdvara. Ramverkets starka beroende på strukturerad utdata gör det utmanande för mindre lokala modeller att utföra pålitligt.

Vad är Cognee?

Cognee är ett öppen källkod Pythonramverk som är designat för att bygga kunskapsgrafer från ostrukturerade dokument med hjälp av LLMs. Skiljer sig från traditionella RAG-system som bara delar upp och embedder dokument, försöker Cognee skapa en semantisk förståelse genom att extrahera entiteter, relationer och koncept till en grafdatabas. Detta tillvägagångssätt är i linje med avancerade RAG-arkitekturer som GraphRAG, som lovar bättre kontextuell hämtning.

Ramverket stöder flera bakändar:

  • Vektor-databaser: LanceDB (standard), med stöd för andra vektorlager
  • Grafdatabaser: Kuzu (standard), som möjliggör komplexa relationssökningar
  • LLM-leverantörer: OpenAI, Anthropic, Ollama och andra
  • Strukturerade utdata-ramverk: BAML och Instructor för begränsad generering

För entusiaster som vill självvärda, gör Cognees kompatibilitet med Ollama det attraktivt för lokala distributioner. Dock är det i detaljerna som det blir problematiskt – som vi kommer att se, skapar kraven på strukturerad utdata betydande utmaningar för mindre modeller.

Varför Strukturerad Utdata Är Viktig

Cognee bygger starkt på strukturerad utdata för att extrahera information från dokument i en konsekvent format. När ett dokument bearbetas måste LLM returnera korrekt formaterad JSON som innehåller entiteter, relationer och metadata. Det är här många mindre modeller har svårt.

Om du arbetar med strukturerad utdata i dina egna projekt, är det avgörande att förstå dessa begränsningar. De utmaningar jag mötte med Cognee speglar bredare problem i LLM-ekosystemet när man arbetar med lokala modeller.

Konfigurationsinställningar

Här är min fungerande konfiguration för Cognee med Ollama. Observera de viktiga inställningarna som möjliggör lokal drift:

TELEMETRY_DISABLED=1

# STRUCTURED_OUTPUT_FRAMEWORK="instructor"
STRUCTURED_OUTPUT_FRAMEWORK="BAML"  

# LLM-konfiguration 
LLM_API_KEY="ollama"  
LLM_MODEL="gpt-oss:20b"
LLM_PROVIDER="ollama"  
LLM_ENDPOINT="http://localhost:11434/v1"
# LLM_MAX_TOKENS="25000"


# Embedding-konfiguration
EMBEDDING_PROVIDER="ollama"  
EMBEDDING_MODEL="avr/sfr-embedding-mistral:latest"  
EMBEDDING_ENDPOINT="http://localhost:11434/api/embeddings"  
EMBEDDING_DIMENSIONS=4096  
HUGGINGFACE_TOKENIZER="Salesforce/SFR-Embedding-Mistral"  

# BAML-konfiguration
BAML_LLM_PROVIDER="ollama"  
BAML_LLM_MODEL="gpt-oss:20b" 

BAML_LLM_ENDPOINT="http://localhost:11434/v1"


# Databasinställningar (standardvärden)
DB_PROVIDER="sqlite"  
VECTOR_DB_PROVIDER="lancedb"  
GRAPH_DATABASE_PROVIDER="kuzu"

# Autentisering
REQUIRE_AUTHENTICATION=False
ENABLE_BACKEND_ACCESS_CONTROL=False

Viktiga Konfigurationsval

Strukturerad Utdata Ramverk: Jag testade BAML, vilket ger bättre kontroll över utdata-schema jämfört med grundläggande promptning. BAML är designat specifikt för strukturerad LLM-utdata, vilket gör det en naturlig passning för kunskapsgrafextraktion.

LLM-leverantör: Genom att använda Ollama:s OpenAI-kompatibla API-slutpunkt (/v1) möjliggör Cognee att behandla det som någon annan OpenAI-stil service.

Embeddingsmodell: SFR-Embedding-Mistral-modellen (4096 dimensioner) ger högkvalitativa embeddings. För mer information om val av embeddingsmodell och prestanda, erbjuder Qwen3 embeddingsmodeller utmärkta alternativ med starka multilinguala förmågor.

Databaser: SQLite för metadata, LanceDB för vektorer och Kuzu för kunskapsgrafen håller allt lokalt utan externa beroenden.

Installera Cognee

Installationen är enkel genom att använda uv (eller pip). Jag rekommenderar att använda uv för snabbare beroendebeslut:

uv venv && source .venv/bin/activate
uv pip install cognee[ollama]
uv pip install cognee[baml]
uv pip install cognee[instructor]

uv sync --extra scraping
uv run playwright install
sudo apt-get install libavif16

De [ollama], [baml] och [instructor]-extra inställningarna installerar nödvändiga beroenden för lokal LLM-drift och strukturerad utdata. Den scraping-extra inställningen lägger till webbscraping-förmåga, medan Playwright möjliggör bearbetning av JavaScript-renderade sidor.

Exempelkod och Användning

Här är den grundläggande arbetsflöde för att bearbeta dokument med Cognee. Först lägger vi till dokument och bygger kunskapsgrafen:

msy-add.py:

import cognee
import asyncio

async def main():

    # Skapa en ren platta för cognee -- återställ data och systemtillstånd
    await cognee.prune.prune_data()
    await cognee.prune.prune_system(metadata=True)
    
    # Lägg till exempeldata
    await cognee.add(
        "/home/rg/prj/prices/msy_parts_price_20251224.pdf",
        node_set=["price_list", "computer_parts", "2025-12-24", "aud"]
    )
    
    # Bearbeta med LLMs för att bygga kunskapsgrafen
    await cognee.cognify()

if __name__ == '__main__':
    asyncio.run(main())

Parametern node_set ger semantiska taggar som hjälper till att kategorisera dokumentet i kunskapsgrafen. Metoden cognify() är där magin (eller problemen) sker – den skickar dokumentets delar till LLM för extraktion av entiteter och relationer.

msy-search.py:

import cognee
import asyncio

async def main():

    # Sök i kunskapsgrafen
    results = await cognee.search(
        query_text="Vilka produkter finns i prislistan?"
#       query_text="Vad är den genomsnittliga priset för 32GB RAM (2x16GB moduler)?"
    )
    
    # Skriv ut
    for result in results:
        print(result)

if __name__ == '__main__':
    asyncio.run(main())

Skiljer sig från traditionell vektorhämtningsmetod i RAG-system, söker Cognee i kunskapsgrafen, vilket teoretiskt möjliggör mer avancerad relationsbaserad hämtning. Detta liknar hur avancerade RAG-arkitekturer fungerar, men kräver att den initiala grafkonstruktionen lyckas.

Testresultat: LLMs prestanda

Jag testade Cognee med ett verkligt användningsfall: att extrahera produktinformation från en datorkomponenter prislistepdf. Det här verkade vara ett idealiskt scenario – strukturerad data i en tabellformat. Här är vad som hände med varje modell:

Modeller som testades

1. gpt-oss:20b (20 miljarder parametrar)

  • Resultat: Misslyckades med teckenkodningsfel
  • Problem: Returnerade felaktigt strukturerad utdata med felaktiga teckenkoder
  • Notering: Även om den är specifikt designad för öppen källkods kompatibilitet, kunde den inte upprätthålla konsekvent JSON-formatering

2. qwen3:14b (14 miljarder parametrar)

  • Resultat: Misslyckades med att producera strukturerad utdata
  • Problem: Modellen skulle generera text men inte i den krävda JSON-schemat
  • Notering: Qwen-modeller presterar vanligtvis bra, men denna uppgift överskred dess förmåga att hantera strukturerad utdata

3. deepseek-r1:14b (14 miljarder parametrar)

  • Resultat: Misslyckades med att producera strukturerad utdata
  • Problem: Liknande qwen3, kunde inte följa BAML-schemakraven
  • Notering: Resonemangsförmågan hjälpte inte med formatet

4. devstral:24b (24 miljarder parametrar)

  • Resultat: Misslyckades med att producera strukturerad utdata
  • Problem: Även med fler parametrar, kunde inte konsekvent generera giltig JSON
  • Notering: Specialiserad kodmodell kampade fortfarande med strikta schema krav

5. ministral-3:14b (14 miljarder parametrar)

  • Resultat: Misslyckades med att producera strukturerad utdata
  • Problem: Mindre modell från Mistral kunde inte hantera kraven på strukturerad utdata

6. qwen3-vl:30b-a3b-instruct (30 miljarder parametrar)

  • Resultat: Misslyckades med att producera strukturerad utdata
  • Problem: Visionförmågan hjälpte inte med extraktion av PDF-tabeller i detta sammanhang

7. gpt-oss:120b (120 miljarder parametrar)

  • Resultat: Kunde inte slutföra bearbetningen efter 2+ timmar
  • Hårdvara: Konsumtions-GPU-konfiguration
  • Problem: Modellen var för stor för praktisk självvärdbaserad användning, även om den kanske skulle ha fungerat till slut

Viktiga upptäckter

Delningsstorlek begränsning: Cognee använder 4k token delar när dokument bearbetas med Ollama. För komplexa dokument eller modeller med större kontextfönster verkar detta onödigt restriktivt. Ramverket ger inte något enkelt sätt att justera denna parameter.

Krav på strukturerad utdata: Det centrala problemet är inte modellintelligens utan formatkompatibilitet. Dessa modeller kan förstå innehållet, men att upprätthålla konsekvent JSON-schema under extraktionsprocessen visar sig vara utmanande. Detta är i linje med bredare utmaningar att få lokala modeller att respektera utdata begränsningar.

Hårdvaraunderlag: Även när en tillräckligt stor modell kanske skulle fungera (som gpt-oss:120b), gör hårdvarukraven det opraktiskt för de flesta självvärdbaserade scenarierna. Du skulle behöva mycket GPU-minne och bearbetningskraft.

Jämförelse med bästa praxis för strukturerad utdata

Den här upplevelsen förstärker lektioner från arbete med strukturerad utdata över olika LLM-leverantörer. Kommerande API:er från OpenAI, Anthropic och Google har ofta inbyggda mekanismer för att tvinga utdata-scheman, medan lokala modeller kräver mer avancerade metoder som grammatikbaserad sampling eller flera valideringspass.

För en djupare analys av välja rätt LLM för Cognee på Ollama, inklusive detaljerade jämförelser av olika modellstorlekar och deras prestandaegenskaper, finns det omfattande guider som kan hjälpa dig att göra ett informerat beslut.

Alternativa tillvägagångssätt för självvärdbaserad RAG

Om du är fast besluten att självvärda och behöver extrahera strukturerad data från dokument, överväg dessa alternativ:

1. Traditionell RAG med enklare extraktion

I stället för att bygga en komplex kunskapsgraf först, använd traditionell RAG med dokumentdelning och vektorhämtnings. För strukturerad dataextraktion:

  • Parsa tabeller direkt med bibliotek som pdfplumber eller tabula-py
  • Använd enklare prompt som inte kräver strikt schema följsamhet
  • Implementera postbearbetningsvalidering i Python snarare än att förlita sig på LLM-utdataformat

2. Specialiserade embeddingsmodeller

Kvaliteten på dina embeddings påverkar starkt hämtningens prestanda. Överväg att använda högpresterande embeddingsmodeller som fungerar bra lokalt. Moderna embeddingsmodeller som Qwen3:s erbjudanden ger utmärkta multilinguala stöd och kan drastiskt förbättra din RAG-systems noggrannhet.

3. Förbättrad hämtning genom omrankning

Även med enklare RAG-arkitekturer kan en omrankningsskede drastiskt förbättra resultat. Efter initial vektorhämtningshämtning kan en omrankningsmodell bedöma relevanten bättre. Den här tvåstegsapprochen ofta överträffar mer komplexa enstegssystem, särskilt när man arbetar med begränsad hårdvara.

4. Hybrid sökstrategier

Kombinera vektorhämtnings med traditionell nyckelsökning (BM25) ger ofta bättre resultat än någon ensam. Många moderna vektorlager stöder hybrid sökning som standard.

5. Överväg alternativa vektorlager

Om du bygger en RAG-system från början, utvärdera olika vektorlager baserat på dina behov. Alternativ finns från lättviktiga inbyggda databaser till distribuerade system som är designade för produktionsnivå.

Docker-distribution överväganden

För produktionsnivå självvärda, förenklar containerisering av din RAG-konfiguration distribution och skalning. När du kör Cognee eller liknande ramverk med Ollama:

# Kör Ollama i en container
docker run -d --gpus=all -v ollama:/root/.ollama -p 1140:1140 --name ollama ollama/ollama

# Hämta dina modeller
docker exec -it ollama ollama pull gpt-oss:20b

# Konfigurera Cognee för att ansluta till container-slutpunkten

Se till att korrekt konfigurera GPU-passthrough och volymmonteringar för modellpersistence.

Lärdomar

1. Matcha verktyg till hårdvara: Cognee är designat för molnskala LLMs. Om du är självvärdbaserad på konsumtionshårdvara, kan enklare arkitekturer vara mer praktiska.

2. Strukturerad utdata är svårt: Att få konsekvent schema följsamhet från lokala LLMs är fortfarande utmanande. Om din applikation kritiskt beroende på strukturerad utdata, använd kommersiella API:er eller implementera robust validering och återförsök logik.

3. Testa tidigt: Innan du commitar till ett ramverk, testa det med din specifika användning och hårdvara. Vad fungerar i demo kan inte fungera på skala eller med dina dokument.

4. Överväg hybridtillvägagångssätt: Använd kommersiella API:er för komplexa extraktionsuppgifter och lokala modeller för enklare frågor för att balansera kostnad och förmåga.

Relaterad läsning

Strukturerad utdata med LLMs

Förståelse av strukturerad utdata är avgörande för ramverk som Cognee. Dessa artiklar går djupare in i att få konsekenta, schemakompatibla svar från LLMs:

RAG-arkitektur och implementering

För alternativa eller kompletterande tillvägagångssätt till kunskapsextraktion och hämtning:

Embedding och omrankning

Förbättra hämtningens kvalitet genom bättre embeddings och omrankning:

Verktyg och resurser

Externa resurser