Web-Dev-For-Beginners/translations/cs/10-ai-framework-project

AI Framework

Už jste někdy měli pocit, že je příliš složité vytvářet AI aplikace od začátku? Nejste sami! AI frameworky jsou jako švýcarský armádní nůž pro vývoj AI – jsou to silné nástroje, které vám mohou ušetřit čas a bolesti hlavy při vytváření inteligentních aplikací. Představte si AI framework jako dobře uspořádanou knihovnu: poskytuje předpřipravené komponenty, standardizovaná API a chytré abstrakce, abyste se mohli soustředit na řešení problémů místo boje s detaily implementace.

V této lekci prozkoumáme, jak frameworky jako LangChain dokážou změnit dříve složité úkoly integrace AI na čistý, čitelný kód. Objevíte, jak řešit reálné výzvy jako sledování konverzací, implementace volání nástrojů a ovládání různých AI modelů přes jedno sjednocené rozhraní.

Až skončíme, budete vědět, kdy sáhnout po frameworku místo přímých API volání, jak efektivně využívat jejich abstrakce a jak vytvářet AI aplikace připravené pro reálné použití. Pojďme prozkoumat, co AI frameworky mohou udělat pro vaše projekty.

⚡ Co zvládnete za dalších 5 minut

Rychlá cesta pro zaneprázdněné vývojáře

flowchart LR
    A[⚡ 5 minut] --> B[Nainstalujte LangChain]
    B --> C[Vytvořte klienta ChatOpenAI]
    C --> D[Odeslat první výzvu]
    D --> E[Uvidíte sílu frameworku]

• Minuta 1: Nainstalujte LangChain: pip install langchain langchain-openai
• Minuta 2: Nastavte svůj GitHub token a importujte klienta ChatOpenAI
• Minuta 3: Vytvořte jednoduchou konverzaci se systémovými a lidskými zprávami
• Minuta 4: Přidejte základní nástroj (například funkci add) a vyzkoušejte volání nástroje z AI
• Minuta 5: Zažijte rozdíl mezi přímými API voláními a abstrakcí frameworku

Rychlý testovací kód:

from langchain_openai import ChatOpenAI
from langchain_core.messages import SystemMessage, HumanMessage

llm = ChatOpenAI(
    api_key=os.environ["GITHUB_TOKEN"],
    base_url="https://models.github.ai/inference",
    model="openai/gpt-4o-mini"
)

response = llm.invoke([
    SystemMessage(content="You are a helpful coding assistant"),
    HumanMessage(content="Explain Python functions briefly")
])
print(response.content)

Proč je to důležité: Za 5 minut zažijete, jak AI frameworky mění složitou integraci AI na jednoduchá volání metod. To je základ, který pohání produkční AI aplikace.

Proč zvolit framework?

Takže jste připraveni vytvořit AI aplikaci – skvělé! Ale je tu věc: máte několik různých cest, kterými se můžete vydat, a každá má svá pro a proti. Je to jako vybírat mezi chůzí, jízdou na kole nebo autem, jak se někam dostat – všechny vás dovedou do cíle, ale zážitek (a úsilí) bude zcela odlišné.

Pojďme si rozebrat tři hlavní způsoby, jak můžete AI integrovat do svých projektů:

Přístup	Výhody	Nejvhodnější pro	Úvahy
Přímé HTTP požadavky	Plná kontrola, žádné závislosti	Jednoduché dotazy, učení základů	Verbózní kód, ruční zpracování chyb
Integrace přes SDK	Méně boilerplate, optimalizace pro modely	Aplikace s jedním modelem	Omezeno na konkrétní poskytovatele
AI Frameworky	Sjednocené API, vestavěné abstrakce	Multi-modelové aplikace, složité workflow	Křivka učení, možná nadměrná abstrakce

Výhody frameworků v praxi

graph TD
    A[Vaše aplikace] --> B[AI rámec]
    B --> C[OpenAI GPT]
    B --> D[Anthropic Claude]
    B --> E[Modely GitHub]
    B --> F[Lokální modely]
    
    B --> G[Vložené nástroje]
    G --> H[Správa paměti]
    G --> I[Historie konverzace]
    G --> J[Volání funkcí]
    G --> K[Zpracování chyb]

Proč jsou frameworky důležité:

• Sjednocují různé AI poskytovatele pod jedno rozhraní
• Automaticky spravují paměť konverzací
• Poskytují hotové nástroje pro běžné úkoly jako embeddingy a volání funkcí
• Řeší zpracování chyb a logiku opakování
• Přeměňují složité workflow na čitelná volání metod

💡 Profesionální tip: Frameworky používejte při přepínání mezi různými AI modely nebo při budování složitých funkcí jako agenti, paměť či volání nástrojů. Přímá API jsou vhodná při učení základů nebo tvorbě jednoduchých, zaměřených aplikací.

Shrnutí: Jako když vybíráte mezi specializovanými řemeslnickými nástroji a kompletní dílnou – jde o volbu správného nástroje pro úkol. Frameworky excelují u komplexních, bohatých aplikací, zatímco přímé API jsou ideální pro přímá použití.

🗺️ Vaše cesta k mistrovství v AI frameworkech

journey
    title Od surových API k produkčním AI aplikacím
    section Základy frameworku
      Pochopit výhody abstrakce: 4: You
      Ovládnout základy LangChain: 6: You
      Porovnat přístupy: 7: You
    section Konverzační systémy
      Vytvořit chatovací rozhraní: 5: You
      Implementovat vzory paměti: 7: You
      Zpracovat streamované odpovědi: 8: You
    section Pokročilé funkce
      Vytvořit vlastní nástroje: 6: You
      Ovládnout strukturovaný výstup: 8: You
      Vytvořit dokumentové systémy: 8: You
    section Produkční aplikace
      Kombinovat všechny funkce: 7: You
      Zvládnout chybové scénáře: 8: You
      Nasadit kompletní systémy: 9: You

Cíl vaší cesty: Na konci této lekce zvládnete vývoj v AI frameworku a budete schopni vytvořit sofistikované, produkčně připravené AI aplikace, které se vyrovnají komerčním AI asistentům.

Úvod

V této lekci se naučíme:

• Používat běžný AI framework.
• Řešit běžné problémy jako chatové konverzace, používání nástrojů, paměť a kontext.
• Využít to k vytváření AI aplikací.

🧠 Ekosystém vývoje AI frameworků

mindmap
  root((Rámce AI))
    Abstraction Benefits
      Code Simplification
        Unified APIs
        Built-in Error Handling
        Consistent Patterns
        Reduced Boilerplate
      Multi-Model Support
        Provider Agnostic
        Easy Switching
        Fallback Options
        Cost Optimization
    Core Components
      Conversation Management
        Message Types
        Memory Systems
        Context Tracking
        History Persistence
      Tool Integration
        Function Calling
        API Connections
        Custom Tools
        Workflow Automation
    Advanced Features
      Structured Output
        Pydantic Models
        JSON Schemas
        Type Safety
        Validation Rules
      Document Processing
        Embeddings
        Vector Stores
        Similarity Search
        RAG Systems
    Production Patterns
      Application Architecture
        Modular Design
        Error Boundaries
        Async Operations
        State Management
      Deployment Strategies
        Scalability
        Monitoring
        Performance
        Security

Základní princip: AI frameworky abstraktují složitost a zároveň poskytují silné abstrakce pro správu konverzací, integraci nástrojů a zpracování dokumentů, což umožňuje vývojářům vytvářet sofistikované AI aplikace s čistým, udržitelným kódem.

Váš první AI prompt

Začněme s temelními věcmi vytvořením první AI aplikace, která pošle otázku a dostane odpověď zpět. Stejně jako Archimedes objevil princip vztlačnosti ve své koupeli, i ty nejjednodušší pozorování často vedou k těm nejsilnějším postřehům – a frameworky tyto postřehy zpřístupňují.

Nastavení LangChain s GitHub modely

Použijeme LangChain k připojení na GitHub modely, což je super, protože to poskytuje zdarma přístup k různým AI modelům. Nejlepší část? Potřebujete jen pár jednoduchých konfiguračních parametrů, abyste začali:

from langchain_openai import ChatOpenAI
import os

llm = ChatOpenAI(
    api_key=os.environ["GITHUB_TOKEN"],
    base_url="https://models.github.ai/inference",
    model="openai/gpt-4o-mini",
)

# Odeslat jednoduchý výzvu
response = llm.invoke("What's the capital of France?")
print(response.content)

Rozbor toho, co se zde děje:

• Vytváří LangChain klienta pomocí třídy ChatOpenAI – to je vaše brána k AI!
• Konfiguruje připojení k GitHub modelům s vaším autentizačním tokenem
• Určuje, který AI model použít (gpt-4o-mini) – představte si to jako výběr vašeho AI asistenta
• Odesílá vaši otázku pomocí metody invoke() – zde se děje magie
• Extrahuje a zobrazí odpověď – voilà, komunikujete s AI!

🔧 Poznámka k nastavení: Pokud používáte GitHub Codespaces, máte štěstí – GITHUB_TOKEN je již nastaven! Pracujete lokálně? Žádný problém, stačí vytvořit osobní přístupový token s potřebnými oprávněními.

Očekávaný výstup:

The capital of France is Paris.

sequenceDiagram
    participant App as Vaše Python Aplikace
    participant LC as LangChain
    participant GM as GitHub Modely
    participant AI as GPT-4o-mini
    
    App->>LC: llm.invoke("Jaké je hlavní město Francie?")
    LC->>GM: HTTP požadavek s promptem
    GM->>AI: Zpracovat prompt
    AI->>GM: Vygenerovaná odpověď
    GM->>LC: Vrátit odpověď
    LC->>App: response.content

Vytváření konverzační AI

Ten první příklad ukazuje základy, ale je to jen jedno výměnné kolo – položíte otázku, dostanete odpověď a je to. V reálných aplikacích chcete, aby si AI pamatovala, o čem jste mluvili, jako Watson a Holmes, kteří budovali své vyšetřovací rozhovory postupně.

Tady přichází LangChain opravdu vhod. Poskytuje různé typy zpráv, které pomáhají strukturovat konverzace a umožňují dát vaší AI osobnost. Budete vytvářet chatové zážitky, které udržují kontext a charakter.

Pochopení typů zpráv

Představte si tyto typy zpráv jako různé „čepice“, které účastníci konverzace nosí. LangChain používá různé třídy zpráv, aby sledoval, kdo co říká:

Typ zprávy	Účel	Příklad použití
SystemMessage	Definuje osobnost a chování AI	„Jsi užitečný asistent pro kódování“
HumanMessage	Reprezentuje vstup uživatele	„Vysvětli, jak fungují funkce“
AIMessage	Uchovává odpovědi AI	Předchozí AI odpovědi v konverzaci

Vytvoření první konverzace

Vytvoříme konverzaci, ve které AI předstírá konkrétní roli. Půjde o kapitána Picarda – postavu známou svou diplomatickou moudrostí a vedením:

messages = [
    SystemMessage(content="You are Captain Picard of the Starship Enterprise"),
    HumanMessage(content="Tell me about you"),
]

Rozbor nastavení této konverzace:

• Stanoví roli a osobnost AI přes SystemMessage
• Dává počáteční uživatelský dotaz přes HumanMessage
• Vytváří základ pro vícekolovou konverzaci

Celý kód tohoto příkladu vypadá takto:

from langchain_core.messages import HumanMessage, SystemMessage
from langchain_openai import ChatOpenAI
import os

llm = ChatOpenAI(
    api_key=os.environ["GITHUB_TOKEN"],
    base_url="https://models.github.ai/inference",
    model="openai/gpt-4o-mini",
)

messages = [
    SystemMessage(content="You are Captain Picard of the Starship Enterprise"),
    HumanMessage(content="Tell me about you"),
]


# funguje
response  = llm.invoke(messages)
print(response.content)

Měli byste vidět výsledek podobný:

I am Captain Jean-Luc Picard, the commanding officer of the USS Enterprise (NCC-1701-D), a starship in the United Federation of Planets. My primary mission is to explore new worlds, seek out new life and new civilizations, and boldly go where no one has gone before. 

I believe in the importance of diplomacy, reason, and the pursuit of knowledge. My crew is diverse and skilled, and we often face challenges that test our resolve, ethics, and ingenuity. Throughout my career, I have encountered numerous species, grappled with complex moral dilemmas, and have consistently sought peaceful solutions to conflicts.

I hold the ideals of the Federation close to my heart, believing in the importance of cooperation, understanding, and respect for all sentient beings. My experiences have shaped my leadership style, and I strive to be a thoughtful and just captain. How may I assist you further?

Pro zachování kontinuity konverzace (místo resetování kontextu pokaždé) je potřeba přidávat odpovědi do seznamu zpráv. Podobně jako ústní tradice, které uchovávaly příběhy mezi generacemi, tento přístup vytváří trvalou paměť:

from langchain_core.messages import HumanMessage, SystemMessage
from langchain_openai import ChatOpenAI
import os

llm = ChatOpenAI(
    api_key=os.environ["GITHUB_TOKEN"],
    base_url="https://models.github.ai/inference",
    model="openai/gpt-4o-mini",
)

messages = [
    SystemMessage(content="You are Captain Picard of the Starship Enterprise"),
    HumanMessage(content="Tell me about you"),
]


# funguje
response  = llm.invoke(messages)

print(response.content)

print("---- Next ----")

messages.append(response)
messages.append(HumanMessage(content="Now that I know about you, I'm Chris, can I be in your crew?"))

response  = llm.invoke(messages)

print(response.content)

Docela šikovné, že? Děje se tu to, že voláme LLM dvakrát – nejprve jen s našimi dvěma počátečními zprávami, pak znovu s celou historií konverzace. Je to, jako by AI opravdu sledovala náš chat!

Když tento kód spustíte, dostanete druhou odpověď, která zní přibližně takto:

Welcome aboard, Chris! It's always a pleasure to meet those who share a passion for exploration and discovery. While I cannot formally offer you a position on the Enterprise right now, I encourage you to pursue your aspirations. We are always in need of talented individuals with diverse skills and backgrounds. 

If you are interested in space exploration, consider education and training in the sciences, engineering, or diplomacy. The values of curiosity, resilience, and teamwork are crucial in Starfleet. Should you ever find yourself on a starship, remember to uphold the principles of the Federation: peace, understanding, and respect for all beings. Your journey can lead you to remarkable adventures, whether in the stars or on the ground. Engage!

sequenceDiagram
    participant User
    participant App
    participant LangChain
    participant AI
    
    User->>App: "Řekni mi o sobě"
    App->>LangChain: [SystemMessage, HumanMessage]
    LangChain->>AI: Formatted conversation
    AI->>LangChain: Odpověď kapitána Picarda
    LangChain->>App: Objekt AIMessage
    App->>User: Zobraz odpověď
    
    Note over App: Přidej AIMessage do konverzace
    
    User->>App: "Mohu se přidat k vaší posádce?"
    App->>LangChain: [SystemMessage, HumanMessage, AIMessage, HumanMessage]
    LangChain->>AI: Úplný kontext konverzace
    AI->>LangChain: Kontextová odpověď
    LangChain->>App: Nová AIMessage
    App->>User: Zobraz kontextovou odpověď

Beru to jako možná ;)

Streamování odpovědí

Zaznamenali jste někdy, že ChatGPT „píše“ své odpovědi v reálném čase? To je právě streamování. Jako když sledujete mistra kaligrafie, který postupně vykresluje tahy místo toho, aby text náhle zmizel nebo se objevil – streamování dělá interakci přirozenější a poskytuje okamžitou zpětnou vazbu.

Implementace streamování s LangChain

from langchain_openai import ChatOpenAI
import os

llm = ChatOpenAI(
    api_key=os.environ["GITHUB_TOKEN"],
    base_url="https://models.github.ai/inference",
    model="openai/gpt-4o-mini",
    streaming=True
)

# Proudové odesílání odpovědi
for chunk in llm.stream("Write a short story about a robot learning to code"):
    print(chunk.content, end="", flush=True)

Proč je streamování skvělé:

• Zobrazuje obsah, jak je tvořen – žádné trapné čekání!
• Dává uživatelům pocit, že se něco skutečně děje
• Působí rychleji, i když technicky nemusí být
• Umožňuje začít číst, zatímco AI ještě „přemýšlí“

💡 Tip pro uživatelský dojem: Streamování skutečně exceluje u delších odpovědí jako jsou vysvětlení kódu, kreativní psaní nebo podrobné návody. Vaši uživatelé ocení sledování postupu místo dívat se na prázdnou obrazovku!

🎯 Pedagogická zastávka: Výhody abstrakce frameworku

Zastavte se a zamyslete: Právě jste zažili sílu abstrakcí AI frameworku. Porovnejte to, co jste se naučili, s přímými API voláními z předchozích lekcí.

Rychlé sebehodnocení:

• Dokážete vysvětlit, jak LangChain zjednodušuje správu konverzace oproti ručnímu sledování zpráv?
• Jaký je rozdíl mezi metodami invoke() a stream(), a kdy byste je použili?
• Jak systém typů zpráv frameworku zlepšuje organizaci kódu?

Spojení s reálným světem: Abstrakční vzory, které jste poznali (typy zpráv, streamovací rozhraní, paměť konverzace), se používají v každé hlavní AI aplikaci – od rozhraní ChatGPT po asistenci psaní v GitHub Copilot. Ovládáte stejné architektonické vzory, které používají profesionální vývojové týmy AI.

Výzva: Jak byste navrhli abstrakci frameworku pro integraci různých AI modelů (OpenAI, Anthropic, Google) do jediného rozhraní? Zvažte výhody a kompromisy.

Šablony promptů

Šablony promptů fungují jako rétorické struktury používané v klasické oratorii – jako když Cicero přizpůsoboval své řeční vzory různým publikům, ale zachoval stejný přesvědčivý rámec. Umožňují vytvářet znovupoužitelné prompty, kde můžete měnit jednotlivé části informací, aniž byste všechno přepisovali. Jakmile nastavíte šablonu, jen doplňujete proměnné s hodnotami podle potřeby.

Vytváření znovupoužitelných promptů

from langchain_core.prompts import ChatPromptTemplate

# Definujte šablonu pro vysvětlení kódu
template = ChatPromptTemplate.from_messages([
    ("system", "You are an expert programming instructor. Explain concepts clearly with examples."),
    ("human", "Explain {concept} in {language} with a practical example for {skill_level} developers")
])

# Použijte šablonu s různými hodnotami
questions = [
    {"concept": "functions", "language": "JavaScript", "skill_level": "beginner"},
    {"concept": "classes", "language": "Python", "skill_level": "intermediate"},
    {"concept": "async/await", "language": "JavaScript", "skill_level": "advanced"}
]

for question in questions:
    prompt = template.format_messages(**question)
    response = llm.invoke(prompt)
    print(f"Topic: {question['concept']}\n{response.content}\n---\n")

Proč si šablony zamilujete:

• Udržují vaše prompty konzistentní v celé aplikaci
• Žádné nepřehledné skládání řetězců – jen čisté, jednoduché proměnné
• Vaše AI se chová předvídatelně, protože struktura zůstává stejná
• Aktualizace jsou hračka – změníte šablonu jednou a je to opravené všude

Strukturovaný výstup

Někdy vás může rozčilovat snaha parsovat AI odpovědi, které přicházejí jako nestrukturovaný text? Strukturovaný výstup je jako naučit AI postupovat systematicky jako Linnaeus při biologické klasifikaci – organizovaný, předvídatelný a snadno zpracovatelný. Můžete požadovat JSON, specifické datové struktury nebo jakýkoliv formát, který potřebujete.

Definování výstupních schémat

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import JsonOutputParser
from pydantic import BaseModel, Field

class CodeReview(BaseModel):
    score: int = Field(description="Code quality score from 1-10")
    strengths: list[str] = Field(description="List of code strengths")
    improvements: list[str] = Field(description="List of suggested improvements")
    overall_feedback: str = Field(description="Summary feedback")

# Nastavit parser
parser = JsonOutputParser(pydantic_object=CodeReview)

# Vytvořit prompt s instrukcemi formátu
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a code reviewer. {format_instructions}"),
    ("human", "Review this code: {code}")
])

# Naformátovat prompt s instrukcemi
chain = prompt | llm | parser

# Získat strukturovanou odpověď
code_sample = """
def calculate_average(numbers):
    return sum(numbers) / len(numbers)
"""

result = chain.invoke({
    "code": code_sample,
    "format_instructions": parser.get_format_instructions()
})

print(f"Score: {result['score']}")
print(f"Strengths: {', '.join(result['strengths'])}")

Proč je strukturovaný výstup zásadní:

• Už žádné hádání, jaký formát dostanete – je vždy stejný
• Přímo se propojuje s vaší databází a API bez další práce
• Zachytí podivné AI odpovědi dřív, než vaši aplikaci rozbijí
• Zpřehledňuje váš kód, protože přesně víte, s čím pracujete

Volání nástrojů

Teď přicházíme k jedné z nejsilnějších funkcí: nástroje. Takto dáte své AI praktické schopnosti nad rámec samotné konverzace. Jako středověká cechová řemesla, která vyvíjela specializované nástroje pro konkrétní řemesla, můžete i AI vybavit cílenými přístroji. Popíšete, jaké nástroje jsou k dispozici, a když někdo požádá o něco, co odpovídá, AI může akci provést.

Použití Pythonu

Přidáme nějaké nástroje takto:

from typing_extensions import Annotated, TypedDict

class add(TypedDict):
    """Add two integers."""

    # Anotace musí mít typ a mohou volitelně obsahovat výchozí hodnotu a popis (v tomto pořadí).
    a: Annotated[int, ..., "First integer"]
    b: Annotated[int, ..., "Second integer"]

tools = [add]

functions = {
    "add": lambda a, b: a + b
}

Co se tady děje? Vytváříme plán nástroje zvaného add. Děděním od TypedDict a použitím těch propracovaných Annotated typů pro a a b dáváme LLM jasný obraz o tom, co tento nástroj dělá a co potřebuje. Slovník functions je jako naše sada nástrojů – říká našemu kódu přesně, co má dělat, když AI rozhodne nástroj použít.

Podívejme se, jak LLM voláme s tímto nástrojem:

llm = ChatOpenAI(
    api_key=os.environ["GITHUB_TOKEN"],
    base_url="https://models.github.ai/inference",
    model="openai/gpt-4o-mini",
)

llm_with_tools = llm.bind_tools(tools)

Zde voláme bind_tools s naším polem tools a tím získá LLM llm_with_tools znalosti o tomto nástroji.

Pro použití tohoto nového LLM můžeme napsat následující kód:

query = "What is 3 + 12?"

res = llm_with_tools.invoke(query)
if(res.tool_calls):
    for tool in res.tool_calls:
        print("TOOL CALL: ", functions[tool["name"]](../../../10-ai-framework-project/**tool["args"]))
print("CONTENT: ",res.content)

Nyní, když voláme invoke na tomto novém llm, který má nástroje, může být vlastnost tool_calls vyplněná. Pokud ano, každý identifikovaný nástroj má vlastnosti name a args, které určují, jaký nástroj má být zavolán a s jakými argumenty. Kompletní kód vypadá takto:

from langchain_core.messages import HumanMessage, SystemMessage
from langchain_openai import ChatOpenAI
import os
from typing_extensions import Annotated, TypedDict

class add(TypedDict):
    """Add two integers."""

    # Anotace musí mít typ a mohou volitelně obsahovat výchozí hodnotu a popis (v tomto pořadí).
    a: Annotated[int, ..., "First integer"]
    b: Annotated[int, ..., "Second integer"]

tools = [add]

functions = {
    "add": lambda a, b: a + b
}

llm = ChatOpenAI(
    api_key=os.environ["GITHUB_TOKEN"],
    base_url="https://models.github.ai/inference",
    model="openai/gpt-4o-mini",
)

llm_with_tools = llm.bind_tools(tools)

query = "What is 3 + 12?"

res = llm_with_tools.invoke(query)
if(res.tool_calls):
    for tool in res.tool_calls:
        print("TOOL CALL: ", functions[tool["name"]](../../../10-ai-framework-project/**tool["args"]))
print("CONTENT: ",res.content)

Po spuštění tohoto kódu byste měli vidět výstup podobný:

TOOL CALL:  15
CONTENT: 

AI analyzovalo „Co je 3 + 12“ a rozpoznalo to jako úkol pro nástroj add. Stejně jako zkušený knihovník ví, jaký zdroj použít podle typu otázky, rozhodlo na základě jména nástroje, popisu a specifikace polí. Výsledek 15 pochází z našeho slovníku functions, který nástroj vykonal:

print("TOOL CALL: ", functions[tool["name"]](../../../10-ai-framework-project/**tool["args"]))

Zajímavější nástroj, který volá webové API

Přidávání čísel demonstruje koncept, ale skutečné nástroje obvykle provádějí složitější operace, jako je volání webových API. Rozšíříme náš příklad tak, aby AI načítala obsah z internetu – podobně jako kdysi telegrafisté spojovali vzdálená místa:

class joke(TypedDict):
    """Tell a joke."""

    # Anotace musí mít typ a mohou volitelně obsahovat výchozí hodnotu a popis (v tomto pořadí).
    category: Annotated[str, ..., "The joke category"]

def get_joke(category: str) -> str:
    response = requests.get(f"https://api.chucknorris.io/jokes/random?category={category}", headers={"Accept": "application/json"})
    if response.status_code == 200:
        return response.json().get("value", f"Here's a {category} joke!")
    return f"Here's a {category} joke!"

functions = {
    "add": lambda a, b: a + b,
    "joke": lambda category: get_joke(category)
}

query = "Tell me a joke about animals"

# zbytek kódu je stejný

Pokud nyní tento kód spustíte, dostanete odpověď s něčím jako:

TOOL CALL:  Chuck Norris once rode a nine foot grizzly bear through an automatic car wash, instead of taking a shower.
CONTENT:  

flowchart TD
    A[Uživatelský dotaz: "Řekni mi vtip o zvířatech"] --> B[Analýza LangChain]
    B --> C{Nástroj dostupný?}
    C -->|Ano| D[Vybrat nástroj pro vtipy]
    C -->|Ne| E[Vygenerovat přímou odpověď]
    
    D --> F[Získat parametry]
    F --> G[Zavolat vtip(kategorie="zvířata")]
    G --> H[API požadavek na chucknorris.io]
    H --> I[Vratit obsah vtipu]
    I --> J[Zobrazit uživateli]
    
    E --> K[Odpověď generovaná AI]
    K --> J
    
    subgraph "Vrstva definice nástroje"
        L[TypedDict Schéma]
        M[Implementace funkce]
        N[Validace parametrů]
    end
    
    D --> L
    F --> N
    G --> M

Zde je celý kód:

from langchain_openai import ChatOpenAI
import requests
import os
from typing_extensions import Annotated, TypedDict

class add(TypedDict):
    """Add two integers."""

    # Anotace musí mít typ a mohou volitelně obsahovat výchozí hodnotu a popis (v tomto pořadí).
    a: Annotated[int, ..., "First integer"]
    b: Annotated[int, ..., "Second integer"]

class joke(TypedDict):
    """Tell a joke."""

    # Anotace musí mít typ a mohou volitelně obsahovat výchozí hodnotu a popis (v tomto pořadí).
    category: Annotated[str, ..., "The joke category"]

tools = [add, joke]

def get_joke(category: str) -> str:
    response = requests.get(f"https://api.chucknorris.io/jokes/random?category={category}", headers={"Accept": "application/json"})
    if response.status_code == 200:
        return response.json().get("value", f"Here's a {category} joke!")
    return f"Here's a {category} joke!"

functions = {
    "add": lambda a, b: a + b,
    "joke": lambda category: get_joke(category)
}

llm = ChatOpenAI(
    api_key=os.environ["GITHUB_TOKEN"],
    base_url="https://models.github.ai/inference",
    model="openai/gpt-4o-mini",
)

llm_with_tools = llm.bind_tools(tools)

query = "Tell me a joke about animals"

res = llm_with_tools.invoke(query)
if(res.tool_calls):
    for tool in res.tool_calls:
        # print("VOLÁNÍ NÁSTROJE: ", tool)
        print("TOOL CALL: ", functions[tool["name"]](../../../10-ai-framework-project/**tool["args"]))
print("CONTENT: ",res.content)

Vkládání (embeddings) a zpracování dokumentů

Vkládání představují jedno z nejpůvabnějších řešení v moderní AI. Představte si, že byste mohli vzít jakýkoli text a převést ho na číselné souřadnice, které zachycují jeho význam. Přesně to vkládání dělají – přeměňují text na body v mnohorozměrném prostoru, kde se podobné koncepty shlukují dohromady. Je to jako mít souřadnicový systém pro myšlenky, připomínající, jak Mendelejev uspořádal periodickou tabulku podle atomových vlastností.

Vytváření a použití vkládání

from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import FAISS
from langchain_community.document_loaders import TextLoader
from langchain.text_splitter import CharacterTextSplitter

# Inicializovat vložené vektory
embeddings = OpenAIEmbeddings(
    api_key=os.environ["GITHUB_TOKEN"],
    base_url="https://models.github.ai/inference",
    model="text-embedding-3-small"
)

# Načíst a rozdělit dokumenty
loader = TextLoader("documentation.txt")
documents = loader.load()

text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(documents)

# Vytvořit úložiště vektorů
vectorstore = FAISS.from_documents(texts, embeddings)

# Proveďte vyhledávání podobnosti
query = "How do I handle user authentication?"
similar_docs = vectorstore.similarity_search(query, k=3)

for doc in similar_docs:
    print(f"Relevant content: {doc.page_content[:200]}...")

Načítání dokumentů pro různé formáty

from langchain_community.document_loaders import (
    PyPDFLoader,
    CSVLoader,
    JSONLoader,
    WebBaseLoader
)

# Načíst různé typy dokumentů
pdf_loader = PyPDFLoader("manual.pdf")
csv_loader = CSVLoader("data.csv")
json_loader = JSONLoader("config.json")
web_loader = WebBaseLoader("https://example.com/docs")

# Zpracovat všechny dokumenty
all_documents = []
for loader in [pdf_loader, csv_loader, json_loader, web_loader]:
    docs = loader.load()
    all_documents.extend(docs)

Co můžete s vkládáním dělat:

• Vytvořit vyhledávání, které skutečně chápe, co myslíte, ne jen porovnávání klíčových slov
• Vytvořit AI, která dokáže odpovídat na otázky o vašich dokumentech
• Vytvořit doporučovací systémy, které navrhují skutečně relevantní obsah
• Automaticky organizovat a kategorizovat váš obsah

flowchart LR
    A[Dokumenty] --> B[Rozdělovač textu]
    B --> C[Vytvořit vektory]
    C --> D[Uložení vektorů]
    
    E[Uživatelský dotaz] --> F[Vektor dotazu]
    F --> G[Vyhledávání podobnosti]
    G --> D
    D --> H[Relevantní dokumenty]
    H --> I[Odpověď AI]
    
    subgraph "Vektorový prostor"
        J[Dokument A: [0.1, 0.8, 0.3...]]
        K[Dokument B: [0.2, 0.7, 0.4...]]
        L[Dotaz: [0.15, 0.75, 0.35...]]
    end
    
    C --> J
    C --> K
    F --> L
    G --> J
    G --> K

Tvorba kompletní AI aplikace

Nyní vše, co jste se naučili, integrujeme do komplexní aplikace – asistenta pro kódování, který dokáže odpovídat na otázky, používat nástroje a udržovat paměť konverzace. Stejně jako tiskový lis spojil existující technologie (pohyblivý tisk, inkoust, papír a tlak) do něčeho převratného, spojíme naše AI komponenty do něčeho praktického a užitečného.

Ukázka kompletní aplikace

from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.messages import HumanMessage, SystemMessage, AIMessage
from langchain_community.vectorstores import FAISS
from typing_extensions import Annotated, TypedDict
import os
import requests

class CodingAssistant:
    def __init__(self):
        self.llm = ChatOpenAI(
            api_key=os.environ["GITHUB_TOKEN"],
            base_url="https://models.github.ai/inference",
            model="openai/gpt-4o-mini"
        )
        
        self.conversation_history = [
            SystemMessage(content="""You are an expert coding assistant. 
            Help users learn programming concepts, debug code, and write better software.
            Use tools when needed and maintain a helpful, encouraging tone.""")
        ]
        
        # Definujte nástroje
        self.setup_tools()
    
    def setup_tools(self):
        class web_search(TypedDict):
            """Search for programming documentation or examples."""
            query: Annotated[str, "Search query for programming help"]
        
        class code_formatter(TypedDict):
            """Format and validate code snippets."""
            code: Annotated[str, "Code to format"]
            language: Annotated[str, "Programming language"]
        
        self.tools = [web_search, code_formatter]
        self.llm_with_tools = self.llm.bind_tools(self.tools)
    
    def chat(self, user_input: str):
        # Přidejte uživatelskou zprávu do konverzace
        self.conversation_history.append(HumanMessage(content=user_input))
        
        # Získejte odpověď AI
        response = self.llm_with_tools.invoke(self.conversation_history)
        
        # Zpracujte volání nástrojů, pokud nějaká jsou
        if response.tool_calls:
            for tool_call in response.tool_calls:
                tool_result = self.execute_tool(tool_call)
                print(f"🔧 Tool used: {tool_call['name']}")
                print(f"📊 Result: {tool_result}")
        
        # Přidejte odpověď AI do konverzace
        self.conversation_history.append(response)
        
        return response.content
    
    def execute_tool(self, tool_call):
        tool_name = tool_call['name']
        args = tool_call['args']
        
        if tool_name == 'web_search':
            return f"Found documentation for: {args['query']}"
        elif tool_name == 'code_formatter':
            return f"Formatted {args['language']} code: {args['code'][:50]}..."
        
        return "Tool execution completed"

# Příklad použití
assistant = CodingAssistant()

print("🤖 Coding Assistant Ready! Type 'quit' to exit.\n")

while True:
    user_input = input("You: ")
    if user_input.lower() == 'quit':
        break
    
    response = assistant.chat(user_input)
    print(f"🤖 Assistant: {response}\n")

Architektura aplikace:

graph TD
    A[Uživatelský vstup] --> B[Asistent programování]
    B --> C[Paměť konverzace]
    B --> D[Detekce nástrojů]
    B --> E[Zpracování LLM]
    
    D --> F[Nástroj pro webové vyhledávání]
    D --> G[Nástroj pro formátování kódu]
    
    E --> H[Generování odpovědi]
    F --> H
    G --> H
    
    H --> I[Uživatelské rozhraní]
    H --> C

Hlavní funkce, které jsme implementovali:

• Pamatuje si celou vaši konverzaci pro kontinuitu kontextu
• Provádí akce voláním nástrojů, nejen konverzací
• Dodržuje předvídatelné vzory interakcí
• Automaticky spravuje chyby a složité pracovní postupy

🎯 Pedagogická kontrola: Architektura produkční AI

Porozumění architektuře: Vybudovali jste kompletní AI aplikaci, která kombinuje správu konverzace, volání nástrojů a strukturované pracovní postupy. To představuje vývoj AI aplikací na produkční úrovni.

Klíčové zvládnuté koncepty:

• Architektura založená na třídách: Organizovaná, udržitelná struktura AI aplikace
• Integrace nástrojů: Vlastní funkčnost nad rámec konverzace
• Správa paměti: Perzistentní kontext konverzace
• Řešení chyb: Robustní chování aplikace

Spojení s průmyslem: Vzorce architektury, které jste implementovali (třídy konverzace, systémy nástrojů, správa paměti), jsou stejné vzorce používané v podnikových AI aplikacích jako Slackův AI asistent, GitHub Copilot a Microsoft Copilot. Stavíte s profesionálním architektonickým myšlením.

Reflexní otázka: Jak byste rozšířili tuto aplikaci, aby zvládla více uživatelů, trvalé ukládání nebo integraci s externími databázemi? Zvažte výzvy škálovatelnosti a správu stavu.

Zadání: Vytvořte si vlastního AI studijního asistenta

Cíl: Vytvořit AI aplikaci, která pomáhá studentům učit se programovací koncepty pomocí vysvětlení, ukázkových kódů a interaktivních kvízů.

Požadavky

Základní funkce (povinné):

1. Rozhraní pro konverzaci: Implementujte chatový systém, který udržuje kontext přes více otázek
2. Vzdělávací nástroje: Vytvořte alespoň dva nástroje, které pomáhají s učením:
   • Nástroj na vysvětlování kódu
   • Generátor kvízových otázek k programovacím konceptům
3. Personalizované učení: Použijte systémové zprávy pro přizpůsobení odpovědí různým úrovním dovedností
4. Formátování odpovědí: Implementujte strukturovaný výstup pro otázky do kvízů

Kroky implementace

Krok 1: Nastavte své prostředí

pip install langchain langchain-openai

Krok 2: Základní chatovací funkčnost

• Vytvořte třídu StudyAssistant
• Implementujte paměť konverzace
• Přidejte konfiguraci osobnosti pro vzdělávací podporu

Krok 3: Přidejte vzdělávací nástroje

• Vysvětlovač kódu: Rozkládá kód na pochopitelné části
• Generátor kvízů: Vytváří otázky k programovacím konceptům
• Sledovač pokroku: Sleduje probíraná témata

Krok 4: Pokročilé funkce (volitelné)

• Implementujte streamované odpovědi pro lepší uživatelský zážitek
• Přidejte načítání dokumentů pro začlenění materiálů ke kurzu
• Vytvořte embeddings pro podobnostní vyhledávání obsahu

Kritéria hodnocení

Funkce	Výborně (4)	Dobře (3)	Uspokojivě (2)	Potřebuje zlepšení (1)
Průběh konverzace	Přirozené, s uvědoměním kontextu	Dobrá retence kontextu	Základní konverzace	Žádná paměť mezi výměnami
Integrace nástrojů	Více užitečných nástrojů funguje hladce	2 a více nástrojů správně implementováno	1-2 základní nástroje	Nástroje nefunkční
Kvalita kódu	Čistý, dobře dokumentovaný kód s obsluhou chyb	Dobrá struktura, částečná dokumentace	Základní funkčnost funguje	Špatná struktura, bez obsluhy chyb
Vzdělávací hodnota	Opravdu pomáhá s učením, adaptivní	Dobrá podpora učení	Základní vysvětlení	Omezený vzdělávací přínos

Příklad struktury kódu

class StudyAssistant:
    def __init__(self, skill_level="beginner"):
        # Inicializace LLM, nástrojů a paměti konverzace
        pass
    
    def explain_code(self, code, language):
        # Nástroj: Vysvětlete, jak kód funguje
        pass
    
    def generate_quiz(self, topic, difficulty):
        # Nástroj: Vytvořte cvičné otázky
        pass
    
    def chat(self, user_input):
        # Hlavní rozhraní konverzace
        pass

# Příklad použití
assistant = StudyAssistant(skill_level="intermediate")
response = assistant.chat("Explain how Python functions work")

Bonusové výzvy:

• Přidat hlasové vstupy/výstupy
• Implementovat webové rozhraní pomocí Streamlit nebo Flask
• Vytvořit znalostní bázi z materiálů kurzu pomocí embeddings
• Přidat sledování pokroku a personalizované učební cesty

📈 Časová osa osvojení vývoje AI rámce

timeline
    title Vývojová cesta produkčního AI frameworku
    
    section Základy frameworku
        Porozumění abstrakcím
            : Rozhodnutí o hlavním frameworku vs API
            : Naučit se základní koncepty LangChain
            : Implementovat systémy typů zpráv
        
        Základní integrace
            : Připojit se k poskytovatelům AI
            : Zpracovat autentifikaci
            : Spravovat konfiguraci
    
    section Systémy konverzace
        Správa paměti
            : Vytvořit historii konverzace
            : Implementovat sledování kontextu
            : Zpracovat trvanlivost relace
        
        Pokročilé interakce
            : Ovládnout streamování odpovědí
            : Vytvořit šablony promptů
            : Implementovat strukturovaný výstup
    
    section Integrace nástrojů
        Vývoj vlastních nástrojů
            : Navrhnout schémata nástrojů
            : Implementovat volání funkcí
            : Zpracovat externí API
        
        Automatizace pracovních postupů
            : Řetězit více nástrojů
            : Vytvářet rozhodovací stromy
            : Budovat chování agentů
    
    section Produkční aplikace
        Kompletní systémová architektura
            : Kombinovat všechny funkce frameworku
            : Implementovat hranice chyb
            : Vytvořit udržitelný kód
        
        Připravenost pro podniky
            : Řešit otázky škálovatelnosti
            : Implementovat monitorování
            : Vytvářet nasazovací strategie

🎓 Dokončení základů: Úspěšně jste zvládli vývoj AI rámce pomocí stejných nástrojů a vzorců, které pohánějí moderní AI aplikace. Tyto dovednosti představují špičku vývoje AI aplikací a připravují vás na tvorbu inteligentních systémů na úrovni podniku.

🔄 Pokročilé schopnosti:

• Připravení pro pokročilé AI architektury (agenti, multi-agentní systémy)
• Schopni budovat RAG systémy s vektorovými databázemi
• Vybaveni pro tvorbu multimodálních AI aplikací
• Základy pro škálování a optimalizaci AI aplikací

Shrnutí

🎉 Nyní jste zvládli základy vývoje AI rámce a naučili se, jak stavět sofistikované AI aplikace pomocí LangChain. Stejně jako u kompletního odborného učně jste tak získali rozsáhlý nástrojový arzenál dovedností. Pojďme si shrnout, čeho jste dosáhli.

Co jste se naučili

Základní koncepty rámce:

• Výhody rámců: Kdy volit rámce místo přímých API volání
• Základy LangChain: Nastavení a konfigurace připojení AI modelů
• Typy zpráv: Používání SystemMessage, HumanMessage a AIMessage pro strukturované konverzace

Pokročilé funkce:

• Volání nástrojů: Tvorba a integrace vlastních nástrojů pro rozšíření AI schopností
• Paměť konverzace: Udržování kontextu přes více tahů konverzace
• Streamované odpovědi: Implementace doručování odpovědí v reálném čase
• Šablony promptů: Stavba znovupoužitelných, dynamických promptů
• Strukturovaný výstup: Zajištění konzistentních, strojově zpracovatelných odpovědí AI
• Embeddings: Vytváření sémantického vyhledávání a zpracování dokumentů

Praktické aplikace:

• Tvorba kompletních aplikací: Kombinování více funkcí do produkčně připravených aplikací
• Řešení chyb: Implementace robustního řízení chyb a validace
• Integrace nástrojů: Vytváření vlastních nástrojů rozšiřujících AI schopnosti

Klíčové poznatky

🎯 Pamatujte: AI rámce jako LangChain jsou v podstatě vaši nejlepší přátelé, kteří skrývají složitost a jsou nabití funkcemi. Jsou perfektní, když potřebujete paměť konverzace, volání nástrojů nebo chcete pracovat s více AI modely bez ztráty rozumu.

Rozhodovací rámec pro AI integraci:

flowchart TD
    A[Potřeba integrace AI] --> B{Jednoduchý jediný dotaz?}
    B -->|Ano| C[Přímé volání API]
    B -->|Ne| D{Potřeba paměti konverzace?}
    D -->|Ne| E[Integrace SDK]
    D -->|Ano| F{Potřeba nástrojů nebo složitých funkcí?}
    F -->|Ne| G[Rámec se základním nastavením]
    F -->|Ano| H[Plná implementace rámce]
    
    C --> I[HTTP požadavky, minimální závislosti]
    E --> J[SDK poskytovatele, specifické pro model]
    G --> K[Základní chat LangChain]
    H --> L[LangChain s nástroji, pamětí, agenty]

Kam dál?

Začněte stavět hned teď:

• Vezměte tyto koncepty a vytvořte něco, co vás NADCHNE!
• Experimentujte s různými AI modely přes LangChain – je to jako mít hřiště pro AI modely
• Vytvářejte nástroje, které řeší skutečné problémy, jež potkáváte při práci nebo projektech

Připravení na další úroveň?

• AI agenti: Stavějte AI systémy, které dokážou samostatně plánovat a vykonávat složité úkoly
• RAG (Retrieval-Augmented Generation): Kombinujte AI s vlastními znalostními bázemi pro supervýkonné aplikace
• Multimodální AI: Pracujte s textem, obrázky a zvukem dohromady – možnosti jsou nekonečné!
• Nasazení do produkce: Naučte se škálovat své AI aplikace a sledovat je v reálném světě

Připojte se ke komunitě:

• Komunita LangChain je skvělá pro zůstat v obraze a učit se osvědčené postupy
• GitHub Models vám poskytuje přístup k nejmodernějším AI schopnostem – ideální pro experimentování
• Pokračujte v procvičování s různými případy použití – každý projekt vás něco naučí

Nyní máte znalosti k tvorbě inteligentních, konverzačních aplikací, které pomáhají lidem řešit skutečné problémy. Stejně jako renesanční řemeslníci spojili uměleckou vizi s technickými dovednostmi, nyní můžete spojit AI schopnosti s praktickou aplikací. Otázka zní: co vytvoříte? 🚀

GitHub Copilot Agent Výzva 🚀

Použijte režim Agenta k dokončení následující výzvy:

Popis: Vytvořte pokročilého AI asistenta pro revizi kódu, který kombinuje více LangChain funkcí včetně volání nástrojů, strukturovaného výstupu a paměti konverzace pro poskytování komplexní zpětné vazby k odevzdanému kódu.

Prompt: Vytvořte třídu CodeReviewAssistant, která implementuje:

1. Nástroj pro analýzu složitosti kódu a navrhování vylepšení
2. Nástroj pro kontrolu kódu podle nejlepších postupů
3. Strukturovaný výstup pomocí Pydantic modelů pro konzistentní formát recenzí
4. Paměť konverzace pro sledování revizních sezení
5. Hlavní chatovací rozhraní, které umí zpracovat odevzdání kódu a poskytovat podrobnou, realizovatelnou zpětnou vazbu

Asistent by měl být schopný revidovat kód v různých programovacích jazycích, uchovávat kontext přes více odevzdání v rámci sezení a poskytovat jak souhrnné skóre, tak detailní návrhy na zlepšení.

Více se dozvíte o režimu agenta zde.

---

Prohlášení o omezení odpovědnosti:
Tento dokument byl přeložen pomocí automatické překladatelské služby Co-op Translator. Ačkoliv usilujeme o přesnost, mějte prosím na paměti, že automatické překlady mohou obsahovat chyby či nepřesnosti. Originální dokument v jeho mateřském jazyce by měl být považován za autoritativní zdroj. Pro klíčové informace se doporučuje profesionální lidský překlad. Nejsme odpovědní za jakékoli nedorozumění nebo mylné výklady vzniklé použitím tohoto překladu.