# 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( a průvodce streamováním.
---
## Stavební bloky, které budete používat 80 % času
### 1) Prompty a parsování výstupu
- Použijte `ChatPromptTemplate` pro strukturované prompty.
- Parsujte výstupy pomocí `StrOutputParser` nebo JSON parserů pro typované odpovědi.
```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(
"""
Shrňte následující text do 3 odrážek:
---
{text}
"""
)
parser = StrOutputParser
chain = prompt | llm | parser
summary = chain.invoke({"text": "LangChain pomáhá vytvářet LLM aplikace s RAG a nástroji."})
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
# Připravte dokumenty
texts = .
---
## Od prototypu k produkci: Podrobný plán
### Krok 1: Definujte uživatelský příběh
- Kdo je uživatel? Jakou práci se snaží dokončit?
- Příklad: „Agent podpory, který odpovídá na otázky týkající se produktu z interních dokumentů a nedávných tiketů.“
### Krok 2: Vyberte minimální životaschopný stack
- Model: Vyberte model za rozumnou cenu a spolehlivý (např. GPT-4o-mini nebo špičkový otevřený model).
- Data: Rozhodněte se, zda potřebujete RAG nyní. Pokud ano, začněte s FAISS lokálně.
- I/O: Použijte LCEL pro rychlou iteraci; vyhněte se vlastnímu kódu propojujícímu různé části.
### Krok 3: Implementujte čistou smyčku RAG
- Správně rozdělte dokumenty.
- Indexujte vložení.
- Promptujte s kontextem a citacemi.
- Přidejte zábranu, abyste se vyhnuli halucinacím, když se nenajde žádný relevantní kontext.
```python
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
qa_prompt = ChatPromptTemplate.from_template(
"""
Odpovězte na otázku POUZE pomocí NÁSLEDUJÍCÍHO KONTEXTU. Pokud odpověď není
v kontextu, řekněte: „Nevím.“ Zahrňte citované ID dokumentů.
KONTEXT:
{context}
OTÁZKA: {question}
"""
)
parser = StrOutputParser
rag_chain = (RunnableParallel(context=retriever, question=RunnableLambda(lambda x: x.
### Krok 5: Typované výstupy a validace
- Použijte `PydanticOutputParser` nebo JSON schéma k vynucení struktury pro API odpovědi.
- Validujte pole, abyste zachytili modelový drift.
### Krok 6: Nástroje a volání funkcí pro skutečné úkoly
- Zavádějte nástroje střídmě.
- Běžné nástroje: kalkulačka, vyhledávání na webu, SQL dotazovací nástroj, spouštěč kódu.
- Jasně popište možnosti nástrojů v docstrings.
### Krok 7: Zabezpečení
- Omezení rychlosti a strategie opakování.
- Časové limity a jističe.
- Bezpečnostní filtry a kontroly obsahu.
### Krok 8: Hodnocení a neustálé zlepšování
- Testujte se zlatými datovými sadami (vstup → očekávaný výstup).
- Vyhodnoťte věrnost, úplnost odpovědí a přesnost citací.
- Měřte míru úspěšnosti načítání a latenci.
---
## Běžné vzory a úskalí
- Začněte jednoduše: Řetězce před agenty. Získáte předvídatelnost a nižší náklady.
- Na dělení záleží: Ladění velikosti/překrytí bloku může změnit kvalitu načítání více než výměna modelu.
- Únik promptu: Necpěte do systémových promptů všechno; udržujte je zaměřené.
- Determinismus: Nastavte `temperature=0` pro hodnocení a kritické pracovní postupy.
- Streamování UX: Streamujte tokeny do UI, zatímco zbytek systému načítá aktiva nebo předběžně načítá kontext.
- Strukturované výstupy: Použijte parsery, aby integrace downstream byla bezbolestná.
---
## Kompletní mini projekt: Otázky a odpovědi k dokumentům s citacemi
Tento příklad spojuje vše dohromady: příjem dat, RAG, generování odpovědí a streamování.
```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) Příjem dat
corpus = {
"pricing": "Náš plán Pro podporuje 1 milion kontextových tokenů a zahrnuje prioritní podporu.",
"limits": "Limit API je 60 požadavků za minutu pro uživatele Pro.",
"security": "Protokoly ukládáme po dobu 30 dnů, pokud není protokolování zakázáno administrátorem.",
}
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(
"""
Jste asistent podpory. K odpovědi použijte KONTEXT.
Pokud si nejste jisti, řekněte: „Nevím.“ Zahrňte citace zdrojových ID.
KONTEXT:
{context}
OTÁZKA: {question}
"""
)
# 4) Model a parser
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
parser = StrOutputParser
# 5) Složte řetězec
rag = (
RunnableParallel(
context=retriever,
question=RunnableLambda(lambda x: x["question"]) # pass-through
)
| prompt
| llm
| parser
)
# 6) Položte otázku
for chunk in rag.stream({"question": "Jaké jsou limity Pro a uchovávání protokolů?"}):
print(chunk, end="", flush=True)