# AI agendid.

Palun kirjelda ja võrdle: CrewAI ja LangChain.

CrewAI on rollipõhiste, koostööd tegevate agentide raamistik; LangChain on laiem LLM‑rakenduste ja agentide “ehituskast”, millele on hiljuti lisandunud tugev agentide ja graafide kiht (LangGraph).  Kui vajad kiiresti üles seatud multi‑agent tiime, on CrewAI mugavam; kui ehitad keerukaid, sügavalt integreeritud LLM‑rakendusi (RAG, stateful töövood), on LangChain üldiselt paindlikum.[^1_1][^1_2][^1_3][^1_4][^1_5][^1_6][^1_7]

## Mis on CrewAI?

CrewAI on Pythonis kirjutatud avatud lähtekoodiga multi‑agendi raamistik, kus defineerid agendid rollide, eesmärkide ja backstory kaudu ning seod need “Crew”‑iks ja “Flow”‑deks.  Arhitektuuri põhiobjektid on Agent, Task, Crew, Process ja Flow, mis annavad rollipõhise tööjaotuse ja kõrgtasemel orkestreerimise (sh tingimuslikud harud, router’id, or_ / and_ loogika).[^1_2][^1_4][^1_8]

Tüüpilised kasutusjuhtumid on uurimistöö, analüüs ja sisuloome, kus mitu spetsialiseeritud agenti (nt uurija, analüütik, kirjutaja) töötavad koos, jagades ülesandeid ja tulemusi.  CrewAI rõhutab autonoomseid agente ja automaatset töövoo juhtimist, et vähendada “boilerplate” koodi ja teha multi‑agent süsteemid kiiremini seadistatavaks.[^1_3][^1_4][^1_6][^1_9][^1_8][^1_2]

## Mis on LangChain?

LangChain on terviklik LLM‑rakenduste raamistik, mis pakub komponendid mudeliteks, tööriistadeks, kettideks, mälu- ja dokumendilaaduriteks ning integratsioonideks vektorpankadega.  Agentide poolel toetub see LangGraph‑ile, mis võimaldab luua püsiva seisundiga agentgraafe (multi‑turn vestlused, inim‑ringis, töövoogude salvestamine, retry’d ja jälgitavus).[^1_10][^1_5][^1_6][^1_11][^1_1]

LangChain sobib hästi projektidele, kus lisaks agentidele on vaja tugevat RAG‑i, keerukaid torustikke, erinevate andmeallikate integreerimist (nt Weaviate, Pinecone) ja detailselt juhitavat täitmist/monitoringut (nt LangSmith).  See tähendab natuke rohkem seadistust, aga vastu saad väga peene kontrolli iga sammu, oleku ja tööriistakõne üle.[^1_5][^1_6][^1_11][^1_1][^1_10]

## CrewAI vs LangChain – olulisemad erinevused

### Fookus ja arhitektuur

| Aspekt | CrewAI | LangChain + LangGraph |
| :-- | :-- | :-- |
| Põhifookus | Rollipõhised koostööd tegevad agenditiimid (“crews”) [^1_2][^1_4] | Üldine LLM‑rakenduste raamistik koos agent‑ ja graafikihtidega [^1_10][^1_5] |
| Orkestreerimine | Crew + Flow, abstraktne runtime juhib agents/Tasks automaatselt [^1_2][^1_6] | Selgesõnalised agentgraafid, oleku- ja sõnumivood, rohkem boilerplate’i [^1_5][^1_6] |
| Autonoomia | Agentidel tugev rolli/eesmärgi kontseptsioon, rõhk autonoomial [^1_2][^1_4] | Agent on üks komponent suuremas graafis; autonoomia sõltub disainist [^1_5][^1_11] |
| Kiire seadistus | Vähe komponente, kiire rollide ja ülesannete kirjeldus [^1_2][^1_4] | Rohkem tükke, suurem paindlikkus, kuid keerukam algus [^1_1][^1_10][^1_5] |

### Tüüpilised kasutusjuhtumid

- CrewAI:
    - Struktureeritud uurimistöö, analüüs ja pika vormi sisu (artiklid, raportid).[^1_4][^1_9][^1_3]
    - Multi‑agent “tiimid”, kus tahad inimesesarnaseid rolle ja lihtsat orkestreerimist (nt “Researcher”, “Writer”, “Reviewer”).[^1_2][^1_4]
- LangChain:
    - RAG, dokumendipõhised chatbotid, keerukad töövood (nt andmete ETL + küsimus‑vastus).[^1_1][^1_10][^1_5]
    - Sügav integratsioon vektorpankade, andmebaaside ja jälgimistööriistadega; vajalik täpne kontroll ja skaleerimine.[^1_6][^1_5][^1_1]


### Tulemuslikkus ja skaleeritavus

Analüüsid viitavad, et CrewAI suudab mõnes QA ja koodigeneraatori stsenaariumis töötada märgatavalt kiiremini kui LangChaini/LangGraphi baasil ehitatud agentgraafid, kuna orkestreerimine on kergem ja IO‑ülekaal väiksem.  LangChain pakub seevastu väga detailset kontrolli iga sammu täitmise üle (async tsüklid, paralleelne täitmine LCEL‑iga), mis sobib hästi suurema koormusega ja rangelt kontrollitud süsteemidele.[^1_12][^1_5][^1_6][^1_1][^1_2]

Skaleerimisel toetub CrewAI ühe runtime’i poolt hallatavatele agentidele ja Flow’dele, samas kui LangChaini/LangGraphi agentgraafid ja LCEL‑ahelad on mõeldud hajusaks, peene graanuliga skaleerimiseks (nt microservice taustal).[^1_5][^1_6][^1_12][^1_2]

## Millal kumba valida (teadus ja lokaalserver)

- Vali pigem CrewAI, kui:
    - Tahad kiiresti püsti saada multi‑agent “tiimi”, mis teeb uurimistööd, analüüsi ja artikli mustandi.[^1_3][^1_4][^1_2]
    - Eelistad rollipõhist, inimest imiteerivat koostööd ja lihtsat, deklaratiivset Flow loogikat.[^1_9][^1_4][^1_2]
- Vali pigem LangChain, kui:
    - Sul on teadusartiklite analüüsi pipeline: PDF‑i ingest, embeddingud Weaviatesse, keerukad RAG‑päringud, agent, kes kasutab mitut tööriista.[^1_10][^1_6][^1_1][^1_5]
    - Vajad tugevat monitoorimist, testimist ja reproduktiivsust (LangSmith), või tahad kasutada LangGraphi keerukate olekumasinate jaoks.[^1_11][^1_1][^1_5]

Praktikas kasutavad paljud meeskonnad LangChaini andmetorustiku ja RAG‑kihi jaoks ning panevad selle ette CrewAI “tiimi”, mis orkestreerib teadusliku töövoo (nt “Literature Researcher” → “Method Analyst” → “Writer”).[^1_4][^1_6][^1_1][^1_2]

## Paigaldus – PopOS 24.04, lokaalne AI server

Allolevad näited eeldavad, et kasutad Python 3.11+ ja tahad joosta mudeleid lokaalselt (nt llama.cpp või Ollama) ning kasutada Weaviate’t vektorpangana.  Kohanda versioonid vastavalt projekti vajadustele.[^1_2][^1_10][^1_5]

### Baastööriistad (bash)

```bash
# Süsteemipakid
sudo apt update
sudo apt install -y build-essential python3 python3-venv python3-pip git

# Projektikaust
mkdir -p ~/ai-agendid && cd ~/ai-agendid

# Virtuaalkeskkond
python3 -m venv .venv
source .venv/bin/activate
pip install --upgrade pip
```


### CrewAI paigaldus ja minimaalne näide

```bash
# CrewAI ja LLM‑klient (nt OpenAI API ühilduv, võib suunata lokaalsele gatewayle)
pip install crewai crewai-tools openai
```

Lihtne multi‑agendi skript teadusartikli kokkuvõtte jaoks:

```python
# crew_science.py
from crewai import Agent, Task, Crew, Process

researcher = Agent(
    role="Teadusartiklite uurija",
    goal="Leida ja kokku võtta olulised tulemused antud teemal",
    backstory="Oled kogenud teadlane, kes otsib ja hindab kriitiliselt publikatsioone."
)

writer = Agent(
    role="Teadusliku kokkuvõtte kirjutaja",
    goal="Koosta lühike, täpne ja viidatud kokkuvõte eesti keeles",
    backstory="Oled teadusajakirja toimetaja, kes väärtustab selgust ja täpsust."
)

research_task = Task(
    description=(
        "Uuri viimase 5 aasta artikleid teemal: {teema}. "
        "Tuvasta peamised tulemused, meetodid ja piirangud."
    ),
    expected_output="Struktureeritud punktid tulemustest, meetoditest ja piirangutest.",
    agent=researcher
)

write_task = Task(
    description=(
        "Võttes aluseks uurija leitud info, kirjuta 1–2 lk eestikeelne kokkuvõte "
        "teadusartikli vormis (sissejuhatus, tulemused, arutelu)."
    ),
    expected_output="Valmis tekst, sobilik teadusliku ülevaatena.",
    agent=writer
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, write_task],
    process=Process.sequential,
    verbose=True,
)

if __name__ == "__main__":
    result = crew.kickoff(inputs={"teema": "multimodaalsed suurmudelid meditsiinis"})
    print(result)
```

Käivitus:

```bash
source .venv/bin/activate
python crew_science.py
```


### LangChain + Weaviate + lokaalne LLM

```bash
pip install "langchain>=0.3" "langchain-community" "langgraph>=0.2" \
            weaviate-client pypdf sentence-transformers
```

Lihtne RAG‑agent teadusartiklite jaoks:

```python
# lc_science_rag.py
from langchain_community.document_loaders import PyPDFLoader
from langchain_community.vectorstores import Weaviate
from langchain.embeddings import HuggingFaceEmbeddings
from langchain_openai import ChatOpenAI
from langchain.chains import RetrievalQA

import weaviate
import os

# Weaviate klient
client = weaviate.Client("http://localhost:8080")
emb = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")

# PDF ingest
loader = PyPDFLoader("artiklid/naited.pdf")
docs = loader.load()

vectorstore = Weaviate.from_documents(
    docs,
    embedding=emb,
    client=client,
    index_name="Articles"
)

retriever = vectorstore.as_retriever(search_kwargs={"k": 5})

llm = ChatOpenAI(
    model="gpt-4o-mini",  # või lokaalne OpenAI‑ühtne gateway
    temperature=0.1,
)

qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    retriever=retriever,
    return_source_documents=True,
)

if __name__ == "__main__":
    question = "Millised on artiklis kirjeldatud meetodid multimodaalsetes mudelites?"
    answer = qa_chain.invoke({"query": question})
    print(answer["result"])
```

Käivitus:

```bash
source .venv/bin/activate
python lc_science_rag.py
```

Kui kirjeldad täpsemini oma teadusartiklite töövoogu (PDF‑id, arXiv API, Zotero jne), saab koostada sulle sobiva kombineeritud arhitektuuri, kus LangChain haldab andme‑ ja otsingukihi ning CrewAI agenttiim tegeleb analüüsi ja kirjutamisega.[^1_6][^1_1][^1_4][^1_5][^1_2]

---

# Kuidas LangChain lahendab oleku ja konteksti säilitamise

LangChain lahendab oleku ja konteksti säilitamise kahel tasemel: “klassikalise” mälu abstraktsioonidega (ConversationBuffer, Summary jne) ning uuemas kihis LangGraphi kaudu, kus mälu on selgesõnaliselt osa graafi olekust ja salvestatakse checkpointeri abil.  See võimaldab nii lühiajalist (sessioonipõhist) kui pikaajalist (püsivat) mälu ning eraldi lõimede/vestluste konteksti.[^2_1][^2_2][^2_3][^2_4][^2_5][^2_6][^2_7]

## Põhiideed: “state” ja “memory”

LangChain eristab mõisteliselt “state’i” (hetkel oluline info) ja “memory’t” (varasemad interaktsioonid, mida saab hiljem meenutada).  Vestluse alguses on olek tühi, iga kasutaja sisend ja mudeli vastus uuendab olekut ning mälu võib salvestada nii lühiajaliselt (sessioon) kui pikaajaliselt (nt Redis, andmebaas).[^2_3][^2_5]

Praktiliselt tähendab see, et sul on objektid, mis hoiavad näiteks sõnumiajalugu, kasutaja eelistusi või viimaseid päringuid, ning need süstitakse automaatselt prompti (nt `{history}` placeholder).[^2_8][^2_9][^2_10]

## Klassikalised mälukomponendid (v0.3+)

“Vanemas” LangChaini kihis on mitut tüüpi mälu, mida saab kettides/agentides kasutada.  Levinumad on:[^2_9][^2_11][^2_8]

- ConversationBufferMemory – hoiab täielikku vestluslogi järjestikuste sõnumitena.[^2_8][^2_9]
- ConversationBufferWindowMemory – hoiab ainult viimased `k` vahetust (aknamälu).[^2_8]
- ConversationSummaryMemory – kasutab LLM‑i, et kokku võtta ajalugu, hoides prompti lühemana.[^2_10][^2_8]

Koodinäide (Python):

```python
from langchain_openai import ChatOpenAI
from langchain.chains import ConversationChain
from langchain.chains.conversation.memory import ConversationSummaryMemory

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

memory = ConversationSummaryMemory(llm=llm)

conversation = ConversationChain(
    llm=llm,
    memory=memory,
    verbose=True,
)

print(conversation.predict(input="Ma olen Mari ja tegelen masinõppega."))
print(conversation.predict(input="Tuleta meelde, mis mu nimi oli ja millega tegelen."))
```

See kett lisab igasse uude prompti vajadusel kokkuvõtte eelnevast vestlusest, nii et mudel “mäletab” kasutaja nime ja huvisid.[^2_11][^2_10][^2_8]

## LangGraph: olek kui graafi mälu

LangGraphi korral käsitletakse mälu kui jagatud olekut (Python dict või dataklass), mis liigub sõlmede (nodes) vahel ja kuhu sõlmed kirjutavad/loevad.  Olek võib sisaldada sõnumiajalugu, töövoo progressi, kasutaja eelistusi, vahepealseid päringu tulemusi jpm, ning graaf toetab tsükleid ja tingimuslikke harusid.[^2_12][^2_13][^2_14][^2_7]

Lühiajaline mälu (thread‑scoped memory) hoitakse graafi olekus ja püsivus saavutatakse checkpointeriga, mis salvestab iga sammu järel oleku andmebaasi, et lõim/vestlus saaks hiljem jätkuda samast kohast.  See sobib eriti multi‑agent ja mitmeastmeliste töövoogude jaoks, kus iga sõlm vajab kogu vajaliku konteksti, aga eri kasutajate vestlused peavad olema eraldatud.[^2_2][^2_4][^2_15][^2_13][^2_1][^2_12]

Lihtne näide skeemist (olek kui sõnumite loend):

```python
from typing import TypedDict, List
from langgraph.graph import StateGraph, END

class ChatState(TypedDict):
    messages: List[dict]

def llm_node(state: ChatState) -> ChatState:
    history = state["messages"]
    # siin kutsud välja LLM-i, sisendiks kogu history
    reply = {"role": "assistant", "content": "Vastus..."}
    return {"messages": history + [reply]}

graph = StateGraph(ChatState)
graph.add_node("chat", llm_node)
graph.set_entry_point("chat")
graph.add_edge("chat", END)

app = graph.compile()
result = app.invoke({"messages": [{"role": "user", "content": "Tere!"}]})
print(result["messages"])
```

Siin on vestlusajalugu selgesõnaliselt osa olekust ja iga sammu järel uuendatakse seda; checkpointeri lisamisel talletub see püsivalt.[^2_4][^2_13][^2_14][^2_1]

## Lühiajaline vs pikaajaline mälu

Lühiajaline mälu (short‑term) hõlmab käesoleva sessiooni/teema vestlusajalugu ja vahetuid vahetulemusi, mida hoitakse kas klassikalises mälukomponendis või LangGraphi olekus.  Pikaajaline mälu (long‑term) rakendatakse tavaliselt väliste salvestitega (Redis, SQL, vektorpangad), kust saab varasemaid fakte või eelistusi uuesti olekusse laadida, kui konkreetne vestlus seda vajab.[^2_5][^2_6][^2_1][^2_3][^2_4][^2_9][^2_10]

Selline eristus võimaldab ehitada agente, kes mäletavad kasutajat ja tema projekte ka pärast sessiooni lõppu, kuid hoiavad LLM‑i kontekstiakna lühikesena, laadides igaks sammuks ainult olulise ajaloo osa.[^2_3][^2_5][^2_9][^2_8]


---

# Millised integratsioonid on kättesaadavad mõlemas raamistikus

LangChain ja CrewAI pakuvad mõlemad laialdast integratsiooni erinevate LLM-pakkujate, andmebaaside, vektorpankade ja tööriistaökosüsteemidega, kuid erinevuse teeb maht ja sügavus: LangChain on ehitatud 1000+ integratsiooniga universaalse platvormina, samas kui CrewAI fokuseerub kitsama, rollipõhiste agentide jaoks optimeeritud tööriistakomplektile (40+ tööriista).[^3_1][^3_2][^3_3][^3_4][^3_5]

## LangChain integratsioonid

LangChain Python pakub **üle 1000 integratsiooni** läbi mitmete kategooriate, mis katavad kogu LLM-rakenduse elutsükli.[^3_2][^3_6][^3_1]

### LLM-mudelid ja pakkujad

LangChain toetab laia valikut mudeli pakkujaid läbi ühtse API:[^3_7][^3_1][^3_2]

- **Kommerts-pakkujad**: OpenAI (GPT-4o, o1), Anthropic (Claude 3.7 Sonnet), Google (Gemini, Vertex AI), Cohere, Mistral AI, Together AI, Groq, Replicate
- **Enterprise**: Azure OpenAI, AWS Bedrock, AWS SageMaker, Google Vertex AI, IBM Watson
- **Lokaalsed/avatud**: Ollama, llama.cpp, HuggingFace, WebLLM
- **Spetsiaalsed**: xAI (Grok), Cloudflare Workers AI, Cerebras, Tencent Hunyuan, SambaNova

Konfigureerimine on lihtne tänu ühtsetele moodulidele (nt `langchain_openai`, `langchain_anthropic`).[^3_7][^3_2]

### Vektorpangad ja otsing

LangChain pakub ühtset liidest **20+ vektorpanga** jaoks:[^3_8][^3_9][^3_10][^3_11][^3_12]

- **Lokaalsed/failipõhised**: FAISS, Chroma, SQLite-VSS
- **Pilve hallatavad**: Pinecone, Weaviate, Qdrant, Milvus, MongoDB Atlas Vector Search, Supabase
- **Olemasolevad andmebaasid**: PostgreSQL (pgvector), Elasticsearch, Redis
- **Enterprise**: Google Vertex AI Vector Search, AWS OpenSearch, SAP HANA Vector, Xata

Kõik vektorpangad jagavad sama API'd (`add_documents`, `similarity_search`, `delete`), mis võimaldab neid vaheldada minimaalsete koodimuudatustega.[^3_9][^3_10][^3_12][^3_8]

Näide PostgreSQL + pgvector integratsioonist:

```python
from langchain_community.vectorstores import PGVector
from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings()

vectorstore = PGVector(
    collection_name="teadusartiklid",
    connection_string="postgresql://user:pass@localhost:5432/dbname",
    embedding_function=embeddings,
)

vectorstore.add_documents(docs)
results = vectorstore.similarity_search("multimodaalsed mudelid", k=5)
```


### Dokumendilaadijad

LangChain sisaldab **100+ dokumendilaadijat** erinevatest allikatest:[^3_1][^3_2]

- **Failivormingud**: PDF, CSV, JSON, DOCX, Markdown, HTML
- **API-d**: ArXiv, Wikipedia, YouTube, GitHub, Google Drive, Notion
- **Veebikraapijad**: BeautifulSoup, Playwright, Selenium, Spider API, Cheerio
- **Enterprise andmeallikad**: SharePoint, Confluence, Slack, Discord, Gmail
- **Andmebaasid**: SQL, MongoDB, Airtable
- **Audio**: AssemblyAI, Sonix (transkriptsioon)


### Retrieverid ja päringuvõimendus

LangChain toetab keerukaid päringustrateegiaid:[^3_2][^3_1]

- **Hübriidotsing**: BM25 (märksõnad) + vektorotsing
- **Edasijõudnud tehnikad**: HyDE (Hypothetical Document Embeddings), Multi-Query Retriever, Parent Document Retriever
- **Enterprise otsingumootorid**: Amazon Kendra, Bedrock Knowledge Bases, Chaindesk


### Tööriistad ja toolkitid

LangChain Agent Toolkit sisaldab tööriistakomplekte:[^3_1][^3_2]

- Veebiotsing (Tavily, Serper, DuckDuckGo)
- Koodi täitmine (Python REPL, Bash)
- SQL andmebaasid (SQLDatabaseToolkit)
- API integratsioonid (Zapier, REST)


## CrewAI integratsioonid

CrewAI keskendub rollipõhistele agentidele ja pakub **40+ spetsialiseeritud tööriista** ning laia LLM-pakkujate tuge läbi LiteLLM.[^3_3][^3_4][^3_13][^3_5]

### LLM-mudelid

CrewAI kasutab **LiteLLM-i** ja toetab samu pakkujaid nagu LangChain:[^3_14][^3_5][^3_15][^3_16]

- OpenAI, Anthropic, Google (Gemini, Vertex AI), Azure OpenAI
- AWS Bedrock, AWS SageMaker, Cohere, VoyageAI
- HuggingFace, Ollama, Mistral AI, Replicate, Together AI
- Groq, SambaNova, DeepInfra, Cloudflare Workers AI, NVIDIA NIMs

Vaikimisi kasutab CrewAI `gpt-4o-mini` mudelit. Konfigureerimine:

```python
from crewai import Agent, LLM

llm = LLM(
    model="ollama/llama3.1",  # või "anthropic/claude-3-5-sonnet-20241022"
    base_url="http://localhost:11434",
    temperature=0.7
)

agent = Agent(
    role="Uurija",
    goal="Analüüsi teadusartikleid",
    llm=llm
)
```


### CrewAI tööriistad (40+)

CrewAI pakub **spetsialiseeritud tööriistakomplekti** läbi `crewai-tools` paketi:[^3_4][^3_13][^3_17][^3_18][^3_19][^3_3]

**Veebiotsing ja -kraap**:

- SerperDevTool, EXASearchTool (AI-otsingud)
- BraveSearchTool
- ScrapeWebsiteTool, SeleniumScrapingTool
- WebsiteSearchTool, SpiderTool

**RAG ja dokumentide töötlus**:

- PDFSearchTool, DOCXSearchTool, TXTSearchTool
- CSVSearchTool, JSONSearchTool, XMLSearchTool
- MDXSearchTool, YoutubeVideoSearchTool

**Vektorpangad**:

- WeaviateVectorSearchTool
- QdrantVectorSearchTool
- MongoDBVectorSearchTool

**API ja koodi**:

- CodeInterpreterTool (koodi täitmine isoleeritud keskkonnas)
- GithubSearchTool
- ComposioTool (100+ API integratsioon läbi Composio platvormi)
- ApifyActorsTool (web scraping agendid)

**AI ja loovus**:

- DallETool (pildigenereerimine)
- VisionTool (pildianalüüs)
- StagehandTool

**Failioperatsioonid**:

- FileWriteTool, FileReadTool
- DirectorySearchTool, DirectoryReadTool

Tööriista kasutamine on lihtne:

```python
from crewai import Agent, Task
from crewai_tools import PDFSearchTool, SerperDevTool

pdf_tool = PDFSearchTool(pdf='artiklid/uurimus.pdf')
search_tool = SerperDevTool()

researcher = Agent(
    role="Teadusuurija",
    goal="Leia asjakohast infot",
    tools=[pdf_tool, search_tool],
    verbose=True
)
```


### Andmebaasid

CrewAI saab ühenduda SQL andmebaasidega läbi custom tööriistade:[^3_20][^3_21]

```python
from crewai_tools import tool
import sqlalchemy

ENGINE = sqlalchemy.create_engine('postgresql://user:pass@localhost:5432/db')

@tool("execute_sql")
def execute_sql(sql_query: str) -> str:
    """Täida SQL päring andmebaasi vastu."""
    with ENGINE.connect() as conn:
        result = conn.execute(sqlalchemy.text(sql_query))
        return str(result.fetchall())
```


### RAG ja dokumendi salvestus

CrewAI toetab automaatset RAG-i läbi Knowledge:[^3_22][^3_23]

- Vaikimisi kasutatakse ChromaDB vektorpanka
- Toetab PDF, CSV, XLSX, JSON formaate
- MongoDB Vector Search Tool integratsiooni


## Võrdlus: LangChain vs CrewAI integratsioonid

| **Aspekt** | **LangChain** | **CrewAI** |
| :-- | :-- | :-- |
| **LLM pakkujad** | 1000+ integratsiooni, natiivsed paketid igale pakkujale [^3_1][^3_2] | LiteLLM ühtsus, sama lai valik [^3_14][^3_5] |
| **Vektorpangad** | 20+ ühtne API (FAISS, Weaviate, Pinecone jt) [^3_8][^3_10] | 3 built-in tööriista (Weaviate, Qdrant, MongoDB) [^3_3] |
| **Dokumendilaadijad** | 100+ (PDF, CSV, API-d, web scrapers) [^3_1][^3_2] | RAG tööriistad (PDF, CSV, JSON, YouTube jt) [^3_3][^3_4] |
| **Tööriistad** | Toolkit süsteem, agent toolkits, custom tools [^3_1][^3_2] | 40+ rollipõhist tööriista (SerperDev, Composio, Vision) [^3_3][^3_4] |
| **Andmebaasid** | Natiivsed SQL/NoSQL integratsioonid, retrieverid [^3_2][^3_10] | Custom tools + SQLAlchemy [^3_20][^3_21] |
| **Lõimutud ökosüsteem** | LangSmith (jälgimine), LangServe (deployment) [^3_24][^3_2] | AgentOps (monitooring), Enterprise (haldus) [^3_19] |

## Paigaldus ja konfiguratsioon – PopOS 24.04

### LangChain integratsioonid lokaalselt

```bash
# Põhipakett + levinumad integratsioonid
pip install "langchain>=0.3" "langchain-community" "langgraph>=0.2"

# Mudelid
pip install langchain-openai langchain-anthropic langchain-ollama

# Vektorpangad
pip install weaviate-client chromadb faiss-cpu

# Dokumendilaadijad
pip install pypdf unstructured python-magic sentence-transformers

# SQL
pip install "langchain-community[postgres]" psycopg2-binary
```

Weaviate + LangChain näide:

```python
from langchain_community.vectorstores import Weaviate
from langchain_community.document_loaders import ArxivLoader
from langchain_openai import OpenAIEmbeddings
import weaviate

client = weaviate.Client("http://localhost:8080")
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

# Laadi artiklid arXiv-ist
loader = ArxivLoader(query="LLM agents", max_results=10)
docs = loader.load()

vectorstore = Weaviate.from_documents(
    docs, embeddings, client=client, index_name="Arxiv"
)

retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
results = retriever.get_relevant_documents("multi-agent süsteemid")
```


### CrewAI integratsioonid lokaalselt

```bash
# Põhipakett + tööriistad
pip install crewai crewai-tools

# LLM pakkujad (vajadusel)
pip install openai anthropic ollama

# Vektorpangad (kui kasutad)
pip install weaviate-client qdrant-client pymongo
```

CrewAI + lokaalne Ollama + PDF RAG:

```python
from crewai import Agent, Task, Crew, LLM
from crewai_tools import PDFSearchTool, SerperDevTool

llm = LLM(model="ollama/llama3.1", base_url="http://localhost:11434")

pdf_tool = PDFSearchTool(pdf='teadusartiklid/uurimus.pdf')
web_tool = SerperDevTool()

researcher = Agent(
    role="Teadusuurija",
    goal="Ekstra artiklid PDF-ist ja veebist teemal {teema}",
    backstory="Oled kriitiline uurija, kes kontrollib allikaid.",
    tools=[pdf_tool, web_tool],
    llm=llm,
    verbose=True
)

task = Task(
    description="Otsi infot teemal {teema} ja koosta 200-sõnaline kokkuvõte.",
    expected_output="Struktureeritud kokkuvõte põhitulemustega.",
    agent=researcher
)

crew = Crew(agents=[researcher], tasks=[task], verbose=True)
result = crew.kickoff(inputs={"teema": "agentic RAG"})
print(result)
```


## Soovitus AMD Ryzen AI Max+ 395 süsteemile

Sinu riistvara (128GB RAM, 2TB SSD) sobib suurepäraselt **mõlema raamistiku** lokaalseks kasutamiseks. Praktiline lähenemine:

1. **LangChain** – RAG pipeline (PDF laadijad, Weaviate, kompleksed päringud)
2. **CrewAI** – multi-agent tiim (uurija, analüütik, kirjutaja)
3. **Lokaalsed mudelid** – Ollama (llama3.1, mistral, qwen) või llama.cpp

Hübriidlahendus:

```python
# LangChain päringusüsteem
from langchain_community.vectorstores import Weaviate
retriever = Weaviate(...).as_retriever()

# CrewAI agenttiim, mis kasutab LangChain retrieverit custom tool'ina
from crewai_tools import tool

@tool("weaviate_search")
def search_papers(query: str) -> str:
    """Otsi teadusartikleid Weaviate vektorpangast."""
    docs = retriever.get_relevant_documents(query)
    return "\n\n".join([d.page_content for d in docs])

# Nüüd CrewAI agent saab kasutada seda tööriista
```

Täpsem töövoo loogikat ja Dockeri seadistusi saab lisada vastavalt sinu konkreetsetele vajadustele (näiteks arXiv API, Zotero, Jupyter integratsiooni).
