# pip install langchain langchain-openai
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
# 1) Model
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
# 2) Prompt
prompt = ChatPromptTemplate.from_messages( și ghid de streaming.
---
## Module de bază pe care le vei folosi în 80% din timp
### 1) Prompt-uri și parsarea ieșirilor
- Utilizează `ChatPromptTemplate` pentru prompt-uri structurate.
- Parsează ieșirile cu `StrOutputParser` sau parsere JSON pentru răspunsuri tipizate.
```python
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-4o-mini")
prompt = ChatPromptTemplate.from_template(
"""
Sumarizează următorul text în 3 puncte:
---
{text}
"""
)
parser = StrOutputParser
chain = prompt | llm | parser
summary = chain.invoke({"text": "LangChain ajută la construirea de aplicații LLM cu RAG și instrumente."})
print(summary)

# pip install faiss-cpu tiktoken
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores import FAISS
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_core.prompts import ChatPromptTemplate
# Pregătește documentele
texts = .
---
## De la prototip la producție: Un plan pas cu pas
### Pasul 1: Definește povestea utilizatorului
- Cine este utilizatorul? Ce încearcă să facă?
- Exemplu: „Un agent de suport care răspunde la întrebări despre produse din documente interne și tichete recente.”
### Pasul 2: Alege stiva minimă viabilă
- Model: Alege un model fiabil, cu preț rezonabil (de exemplu, GPT-4o-mini sau un model deschis de frontieră).
- Date: Decide dacă ai nevoie de RAG acum. Dacă da, începe cu FAISS local.
- I/O: Utilizează LCEL pentru iterație rapidă; evită codul de lipire personalizat.
### Pasul 3: Implementează o buclă RAG curată
- Împarte documentele corect.
- Indexează încorporările.
- Solicită cu context și citări.
- Adaugă o balustradă pentru a evita halucinațiile atunci când nu se găsește un context relevant.
```python
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
qa_prompt = ChatPromptTemplate.from_template(
"""
Răspunde la întrebare folosind DOAR CONTEXTUL de mai jos. Dacă răspunsul nu se află în context, spune "Nu știu". Include ID-urile documentelor citate.
CONTEXT:
{context}
ÎNTREBARE: {question}
"""
)
parser = StrOutputParser
rag_chain = (RunnableParallel(context=retriever, question=RunnableLambda(lambda x: x.
### Pasul 5: Ieșiri tipizate și validare
- Utilizează `PydanticOutputParser` sau schema JSON pentru a impune structura răspunsurilor API.
- Validează câmpurile pentru a prinde deviația modelului.
### Pasul 6: Instrumente și apelarea funcțiilor pentru sarcini reale
- Introdu instrumente cu moderație.
- Instrumente comune: calculator, căutare web, executor de interogări SQL, runner de cod.
- Descrie clar capacitățile instrumentelor în docstrings.
### Pasul 7: Consolidare
- Limită de rată și strategii de reîncercare.
- Timeout-uri și întrerupătoare de circuit.
- Filtre de siguranță și verificări de conținut.
### Pasul 8: Evaluare și îmbunătățire continuă
- Testează cu seturi de date de aur (intrare → ieșire așteptată).
- Evaluează fidelitatea, completitudinea răspunsului și acuratețea citării.
- Măsoară rata de succes a recuperării și latența.
---
## Modele comune și capcane
- Începe simplu: Lanțuri înainte de agenți. Vei obține predictibilitate și costuri mai mici.
- Chunking contează: Ajustarea dimensiunii/suprapunerii chunk-urilor poate schimba calitatea recuperării mai mult decât schimbarea modelului.
- Scurgeri de prompt: Nu băga tot ce găsești în prompt-urile sistemului; păstrează-le concentrate.
- Determinism: Setează `temperature=0` pentru evaluare și fluxuri de lucru critice.
- UX de streaming: Transmite jetoane către UI în timp ce restul sistemului preia active sau preîncarcă contextul.
- Ieșiri structurate: Utilizează parsere pentru a face integrarea downstream nedureroasă.
---
## Un mini-proiect complet: Î&R despre documente cu citări
Acest exemplu leagă totul: ingestie, RAG, generare de răspunsuri și streaming.
```python
# pip install langchain langchain-openai faiss-cpu tiktoken
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import FAISS
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnableParallel, RunnableLambda
# 1) Ingest
corpus = {
"pricing": "Planul nostru Pro acceptă 1 milion de jetoane de context și include asistență prioritară.",
"limits": "Limita de rată API este de 60 de cereri pe minut pentru utilizatorii Pro.",
"security": "Stocăm jurnalele timp de 30 de zile, cu excepția cazului în care jurnalizarea este dezactivată de administrator.",
}
splitter = RecursiveCharacterTextSplitter(chunk_size=300, chunk_overlap=50)
all_chunks, ids = [], []
for doc_id, text in corpus.items:
for i, chunk in enumerate(splitter.split_text(text)):
all_chunks.append(chunk)
ids.append(f"{doc_id}-{i}")
# 2) Index
db = FAISS.from_texts(all_chunks, OpenAIEmbeddings)
retriever = db.as_retriever(k=4)
# 3) Prompt
prompt = ChatPromptTemplate.from_template(
"""
Ești un asistent de suport. Utilizează CONTEXTUL pentru a răspunde.
Dacă nu ești sigur, spune "Nu știu". Include citări ale ID-urilor sursă.
CONTEXT:
{context}
ÎNTREBARE: {question}
"""
)
# 4) Model și parser
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
parser = StrOutputParser
# 5) Compune lanțul
rag = (
RunnableParallel(
context=retriever,
question=RunnableLambda(lambda x: x["question"]) # pass-through
)
| prompt
| llm
| parser
)
# 6) Pune o întrebare
for chunk in rag.stream({"question": "Care sunt limitele de rată Pro și păstrarea jurnalelor?"}):
print(chunk, end="", flush=True)