48 KiB

Raw Blame History Unescape Escape

AI Framework

Czy kiedykolwiek czułeś się przytłoczony, próbując budować aplikacje AI od podstaw? Nie jesteś sam! Frameworki AI to jak szwajcarski scyzoryk dla programistów AI – to potężne narzędzia, które mogą zaoszczędzić Ci czas i bóle głowy podczas tworzenia inteligentnych aplikacji. Pomyśl o frameworku AI jak o dobrze zorganizowanej bibliotece: zapewnia gotowe komponenty, ustandaryzowane API i sprytne abstrakcje, dzięki czemu możesz skupić się na rozwiązywaniu problemów zamiast zmagać się ze szczegółami implementacji.

W tej lekcji odkryjemy, jak frameworki takie jak LangChain mogą zamienić kiedyś skomplikowane zadania integracji AI w czysty, czytelny kod. Dowiesz się, jak radzić sobie z rzeczywistymi wyzwaniami, takimi jak śledzenie rozmów, implementacja wywoływania narzędzi i zarządzanie różnymi modelami AI za pomocą jednego zunifikowanego interfejsu.

Po ukończeniu dowiesz się, kiedy sięgnąć po frameworki zamiast surowych wywołań API, jak efektywnie korzystać z ich abstrakcji i jak budować aplikacje AI gotowe na rzeczywiste zastosowania. Poznajmy, co frameworki AI mogą zrobić dla Twoich projektów.

⚡ Co możesz zrobić w następnych 5 minut

Szybki start dla zapracowanych programistów

flowchart LR
    A[⚡ 5 minut] --> B[Zainstaluj LangChain]
    B --> C[Utwórz klienta ChatOpenAI]
    C --> D[Wyślij pierwsze zapytanie]
    D --> E[Zobacz moc frameworka]

Minuta 1: Zainstaluj LangChain: pip install langchain langchain-openai
Minuta 2: Skonfiguruj swój token GitHub i zaimportuj klienta ChatOpenAI
Minuta 3: Stwórz prostą rozmowę z wiadomościami systemowymi i od człowieka
Minuta 4: Dodaj podstawowe narzędzie (np. funkcję dodawania) i zobacz wywoływanie narzędzi AI
Minuta 5: Doświadcz różnicy między surowymi wywołaniami API a abstrakcją frameworku

Szybki test kodu:

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)

Dlaczego to ważne: W ciągu 5 minut zobaczysz, jak frameworki AI przekształcają skomplikowaną integrację AI w proste wywołania metod. To fundament, który napędza produkcyjne aplikacje AI.

Dlaczego warto wybrać framework?

Jesteś gotowy, aby zbudować aplikację AI – super! Ale sprawa wygląda tak: masz kilka różnych ścieżek do wyboru, a każda z nich ma swoje plusy i minusy. To trochę jak wybór między chodzeniem, jazdą na rowerze lub autem, żeby gdzieś dotrzeć – wszystkie sposoby doprowadzą Cię do celu, ale doświadczenie (i wysiłek) będą zupełnie inne.

Rozłożymy na czynniki pierwsze trzy główne sposoby integracji AI w Twoich projektach:

Podejście	Zalety	Najlepsze do	Uwagi
Bezpośrednie żądania HTTP	Pełna kontrola, brak zależności	Proste zapytania, nauka podstaw	Bardziej rozbudowany kod, ręczne obsługiwanie błędów
Integracja SDK	Mniej boilerplate’u, optymalizacje specyficzne dla modelu	Aplikacje z jednym modelem	Ograniczone do konkretnych dostawców
Frameworki AI	Zunifikowane API, wbudowane abstrakcje	Aplikacje wielomodelowe, złożone przepływy	Krzywa nauki, możliwość nadmiernej abstrakcji

Korzyści z frameworków w praktyce

graph TD
    A[Twoja Aplikacja] --> B[Framework AI]
    B --> C[OpenAI GPT]
    B --> D[Anthropic Claude]
    B --> E[Modele GitHub]
    B --> F[Modele Lokalnie]
    
    B --> G[Narzędzia Wbudowane]
    G --> H[Zarządzanie Pamięcią]
    G --> I[Historia Konwersacji]
    G --> J[Wywoływanie Funkcji]
    G --> K[Obsługa Błędów]

Dlaczego frameworki są ważne:

Integrują wielu dostawców AI pod jednym interfejsem
Obsługują pamięć rozmowy automatycznie
Dostarczają gotowe narzędzia do typowych zadań jak embeddingi i wywoływanie funkcji
Zarządzają obsługą błędów i logiką ponowień
Przekształcają skomplikowane przepływy w czytelne wywołania metod

💡 Profesjonalna wskazówka: Używaj frameworków, gdy przełączasz się między różnymi modelami AI lub budujesz złożone funkcje, takie jak agenci, pamięć czy wywoływanie narzędzi. Stosuj bezpośrednie API, gdy uczysz się podstaw lub tworzysz proste, skoncentrowane aplikacje.

Podsumowując: Podobnie jak wybór między wyspecjalizowanymi narzędziami rzemieślnika a kompletnym warsztatem, chodzi o dopasowanie narzędzia do zadania. Frameworki sprawdzają się świetnie w złożonych, bogatych funkcjach aplikacjach, podczas gdy bezpośrednie API dobrze działają w prostych zastosowaniach.

🗺️ Twoja podróż naukowa przez mistrzostwo frameworków AI

journey
    title Od surowych API do produkcyjnych aplikacji AI
    section Podstawy frameworka
      Zrozum korzyści abstrakcji: 4: You
      Opanuj podstawy LangChain: 6: You
      Porównaj podejścia: 7: You
    section Systemy konwersacyjne
      Buduj interfejsy czatu: 5: You
      Zaimplementuj wzorce pamięci: 7: You
      Obsługuj odpowiedzi strumieniowe: 8: You
    section Zaawansowane funkcje
      Twórz niestandardowe narzędzia: 6: You
      Opanuj zorganizowany output: 8: You
      Buduj systemy dokumentów: 8: You
    section Aplikacje produkcyjne
      Połącz wszystkie funkcje: 7: You
      Obsługuj scenariusze błędów: 8: You
      Wdrażaj kompletne systemy: 9: You

Cel Twojej podróży: Pod koniec tej lekcji opanujesz rozwój w frameworkach AI i będziesz w stanie tworzyć zaawansowane, gotowe do produkcji aplikacje AI, które konkurują z komercyjnymi asystentami AI.

Wprowadzenie

W tej lekcji nauczysz się:

Korzystać z popularnego frameworku AI.
Rozwiązywać typowe problemy, takie jak rozmowy czatowe, użycie narzędzi, pamięć i kontekst.
Wykorzystywać to do budowania aplikacji AI.

🧠 Ekosystem rozwoju frameworków AI

mindmap
  root((Ramki 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

Główna zasada: Frameworki AI upraszczają złożoność, oferując potężne abstrakcje do zarządzania rozmowami, integracji narzędzi i przetwarzania dokumentów, umożliwiając programistom tworzenie zaawansowanych aplikacji AI z czystym i łatwym w utrzymaniu kodem.

Twój pierwszy prompt AI

Zacznijmy od podstaw, tworząc pierwszą aplikację AI, która wysyła pytanie i otrzymuje odpowiedź. Podobnie jak Archimedes odkrywający zasadę wyporu w swojej kąpieli, czasem najprostsze obserwacje prowadzą do najpotężniejszych wniosków – a frameworki udostępniają te wnioski.

Konfiguracja LangChain z modelami GitHub

Użyjemy LangChain do połączenia się z modelami GitHub, co jest całkiem fajne, ponieważ daje darmowy dostęp do różnych modeli AI. Najlepsza część? Potrzebujesz tylko kilku prostych parametrów konfiguracyjnych, aby zacząć:

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",
)

# Wyślij proste polecenie
response = llm.invoke("What's the capital of France?")
print(response.content)

Oto co się tutaj dzieje:

Tworzy klienta LangChain za pomocą klasy ChatOpenAI – to twój wstęp do AI!
Konfiguruje połączenie do modeli GitHub z Twoim tokenem uwierzytelniającym
Określa, którego modelu AI używać (gpt-4o-mini) – pomyśl o tym jak o wyborze asystenta AI
Wysyła pytanie metodą invoke() – tutaj dzieje się magia
Wyciąga i wyświetla odpowiedź – voilà, rozmawiasz z AI!

🔧 Notatka: Jeśli korzystasz z GitHub Codespaces, masz szczęście – GITHUB_TOKEN jest już skonfigurowany! Pracujesz lokalnie? Spokojnie, będziesz musiał stworzyć token dostępu osobistego z odpowiednimi uprawnieniami.

Oczekiwany wynik:

The capital of France is Paris.

sequenceDiagram
    participant App as Twoja aplikacja Python
    participant LC as LangChain
    participant GM as Modele GitHub
    participant AI as GPT-4o-mini
    
    App->>LC: llm.invoke("Jaka jest stolica Francji?")
    LC->>GM: Żądanie HTTP z podpowiedzią
    GM->>AI: Przetwórz podpowiedź
    AI->>GM: Wygenerowana odpowiedź
    GM->>LC: Zwróć odpowiedź
    LC->>App: response.content

Budowanie konwersacyjnej AI

Ten pierwszy przykład demonstruje podstawy, ale to tylko jedna wymiana – zadajesz pytanie, dostajesz odpowiedź i to wszystko. W rzeczywistych aplikacjach chcesz, aby AI pamiętało, o czym rozmawialiście, tak jak Watson i Holmes budowali swoje śledcze rozmowy na przestrzeni czasu.

Tu LangChain okazuje się szczególnie przydatne. Udostępnia różne typy wiadomości, które pomagają strukturyzować rozmowy i pozwalają nadać AI osobowość. Będziesz tworzyć czaty utrzymujące kontekst i charakter.

Zrozumienie typów wiadomości

Pomyśl o typach wiadomości jak o różnych „kapeluszach”, które uczestnicy noszą w rozmowie. LangChain używa różnych klas wiadomości, by śledzić, kto co mówi:

Typ Wiadomości	Cel	Przykład Zastosowania
`SystemMessage`	Definiuje osobowość i zachowanie AI	"Jesteś pomocnym asystentem programistycznym"
`HumanMessage`	Reprezentuje wejście użytkownika	"Wyjaśnij, jak działają funkcje"
`AIMessage`	Przechowuje odpowiedzi AI	Poprzednie odpowiedzi AI w rozmowie

Tworzenie pierwszej rozmowy

Stwórzmy rozmowę, w której AI przyjmuje konkretną rolę. Niech będzie Kapitanem Picardem – postacią znaną z dyplomatycznej mądrości i przywództwa:

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

Co robi ta konfiguracja rozmowy:

Ustala rolę i osobowość AI przez SystemMessage
Dostarcza wstępne zapytanie użytkownika za pomocą HumanMessage
Tworzy podstawę do rozmowy wieloetapowej

Pełny kod tego przykładu wygląda tak:

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"),
]


# działa
response  = llm.invoke(messages)
print(response.content)

Powinieneś zobaczyć wynik podobny do:

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?

Aby zachować ciągłość rozmowy (zamiast resetować kontekst za każdym razem), musisz ciągle dodawać odpowiedzi do listy wiadomości. Podobnie jak ustne tradycje przekazujące historie z pokolenia na pokolenie, takie podejście buduje trwałą pamięć:

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"),
]


# działa
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)

Całkiem niezłe, prawda? Dzieje się tu tak, że wywołujemy LLM dwukrotnie – najpierw z dwoma początkowymi wiadomościami, a potem ponownie z pełną historią rozmowy. To tak, jakby AI naprawdę śledziło naszą rozmowę!

Kiedy uruchomisz ten kod, otrzymasz drugą odpowiedź, która może brzmieć tak:

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: "Opowiedz mi o sobie"
    App->>LangChain: [SystemMessage, HumanMessage]
    LangChain->>AI: Sformatowana konwersacja
    AI->>LangChain: Odpowiedź Kapitana Picarda
    LangChain->>App: Obiekt AIMessage
    App->>User: Wyświetl odpowiedź
    
    Note over App: Dodaj AIMessage do konwersacji
    
    User->>App: "Czy mogę dołączyć do twojej załogi?"
    App->>LangChain: [SystemMessage, HumanMessage, AIMessage, HumanMessage]
    LangChain->>AI: Pełny kontekst rozmowy
    AI->>LangChain: Odpowiedź kontekstowa
    LangChain->>App: Nowy AIMessage
    App->>User: Wyświetl odpowiedź kontekstową

Wezmę to jako „może” ;)

Streaming odpowiedzi

Czy zauważyłeś, jak ChatGPT zdaje się „pisać” odpowiedzi w czasie rzeczywistym? To właśnie streaming w akcji. Podobnie jak obserwowanie zręcznego kaligrafa – widzisz, jak pojawiają się litery krok po kroku, zamiast natychmiast – streaming sprawia, że interakcja jest bardziej naturalna i daje natychmiastową informację zwrotną.

Implementacja streamingu w 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
)

# Strumieniuj odpowiedź
for chunk in llm.stream("Write a short story about a robot learning to code"):
    print(chunk.content, end="", flush=True)

Dlaczego streaming jest świetny:

Pokazuje zawartość, gdy jest tworzona – koniec z niezręcznym czekaniem!
Sprawia, że użytkownicy czują, iż coś się faktycznie dzieje
Wydaje się szybszy, nawet jeśli technicznie taki nie jest
Pozwala rozpocząć czytanie, podczas gdy AI jeszcze „myśli”

💡 Wskazówka dla UX: Streaming szczególnie błyszczy przy dłuższych odpowiedziach, takich jak wyjaśnienia kodu, kreatywne pisanie czy szczegółowe tutoriale. Twoi użytkownicy pokochają widzieć postęp zamiast patrzeć na pusty ekran!

🎯 Pedagogiczna chwila refleksji: Korzyści abstrakcji frameworku

Zatrzymaj się i pomyśl: Właśnie doświadczyłeś mocy abstrakcji frameworków AI. Porównaj to, czego się nauczyłeś, z surowymi wywołaniami API z poprzednich lekcji.

Szybka autoocena:

Czy potrafisz wyjaśnić, jak LangChain upraszcza zarządzanie rozmową w porównaniu z ręcznym śledzeniem wiadomości?
Jaka jest różnica między metodami invoke() a stream() i kiedy ich używać?
Jak system typów wiadomości w frameworku poprawia organizację kodu?

Połączenie z rzeczywistością: Schematy abstrakcji, które poznałeś (typy wiadomości, interfejsy strumieniowe, pamięć rozmowy) są używane w każdej dużej aplikacji AI – od interfejsu ChatGPT po pomoc kodową GitHub Copilot. Opanowujesz te same wzorce architektoniczne, które stosują profesjonalne zespoły deweloperskie AI.

Pytanie wyzwania: Jak zaprojektowałbyś abstrakcję frameworku do obsługi różnych dostawców modeli AI (OpenAI, Anthropic, Google) za pomocą jednolitego interfejsu? Rozważ korzyści i kompromisy.

Szablony promptów

Szablony promptów działają jak struktury retoryczne stosowane w klasycznej oratorii – pomyśl o tym, jak Cyceron dostosowywał swoje wzorce mowy do różnych odbiorców, zachowując tę samą perswazyjną ramę. Pozwalają tworzyć wielokrotnego użytku pytania, w których można wymieniać różne elementy bez przepisywania wszystkiego od nowa. Po skonfigurowaniu szablonu wystarczy wypełnić zmienne odpowiednimi wartościami.

Tworzenie wielokrotnego użytku promptów

from langchain_core.prompts import ChatPromptTemplate

# Zdefiniuj szablon do wyjaśnień kodu
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")
])

# Użyj szablonu z różnymi wartościami
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")

Dlaczego pokochasz szablony:

Utrzymują spójność promptów w całej aplikacji
Koniec z brzydkim łączeniem stringów – tylko czyste, proste zmienne
Twoje AI zachowuje się przewidywalnie, bo struktura pozostaje niezmienna
Aktualizacje to pestka – zmieniasz szablon raz i zmiana obowiązuje wszędzie

Strukturalne outputy

Czy zdarzyło Ci się frustrować podczas próby analizowania odpowiedzi AI, które wracają jako niestrukturalny tekst? Strukturalny output to jak nauczenie AI, aby stosowało systematyczne podejście, które Linneusz używał do klasyfikacji biologicznej – uporządkowane, przewidywalne i łatwe w obsłudze. Możesz żądać JSON, konkretnych struktur danych lub dowolnego formatu, którego potrzebujesz.

Definiowanie schematów outputu

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")

# Skonfiguruj parser
parser = JsonOutputParser(pydantic_object=CodeReview)

# Utwórz prompt z instrukcjami formatowania
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a code reviewer. {format_instructions}"),
    ("human", "Review this code: {code}")
])

# Sformatuj prompt z instrukcjami
chain = prompt | llm | parser

# Pobierz uporządkowaną odpowiedź
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'])}")

Dlaczego strukturalny output zmienia zasady gry:

Koniec z zgadywaniem, jaki format dostaniesz – jest zawsze spójny
Podłącza się bezpośrednio do Twoich baz danych i API bez dodatkowej pracy
Wykrywa dziwne odpowiedzi AI, zanim zepsują Twoją aplikację
Upraszcza Twój kod, bo dokładnie wiesz, z czym pracujesz

Wywoływanie narzędzi

Teraz docieramy do jednej z najbardziej potężnych funkcji: narzędzi. To sposób, aby dać Twojemu AI praktyczne zdolności wykraczające poza samą rozmowę. Podobnie jak średniowieczne gildie tworzyły specjalistyczne narzędzia do konkretnych rzemiosł, możesz wyposażyć AI w ukierunkowane instrumenty. Opisujesz dostępne narzędzia, a gdy ktoś poprosi o coś, co pasuje do ich zakresu, AI może podjąć działanie.

Używanie Pythona

Dodajmy kilka narzędzi w ten sposób:

from typing_extensions import Annotated, TypedDict

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

    # Adnotacje muszą mieć typ i opcjonalnie mogą zawierać wartość domyślną oraz opis (w tej kolejności).
    a: Annotated[int, ..., "First integer"]
    b: Annotated[int, ..., "Second integer"]

tools = [add]

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

Co tu się dzieje? Tworzymy szablon narzędzia o nazwie add. Dziedzicząc po TypedDict i używając tych fajnych typów Annotated dla a i b, dajemy LLM jasny obraz, co to narzędzie robi i czego potrzebuje. Słownik functions jest jak nasza skrzynka narzędziowa – mówi naszemu kodowi dokładnie, co zrobić, gdy AI zdecyduje się użyć konkretnego narzędzia.

Zobaczmy, jak wywołujemy LLM z tym narzędziem:

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)

Wywołujemy bind_tools z tablicą tools, dzięki czemu nowy LLM llm_with_tools posiada wiedzę o tym narzędziu.

Aby użyć tego nowego LLM, możemy wpisać następujący kod:

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)

Teraz, gdy wywołujemy invoke na tym nowym llm, które ma narzędzia, właściwość tool_calls może zostać wypełniona. Jeśli tak, każde zidentyfikowane narzędzie posiada właściwości name i args, które określają, jakie narzędzie ma być wywołane i z jakimi argumentami. Pełny kod wygląda tak:

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."""

    # Adnotacje muszą mieć typ i mogą opcjonalnie zawierać wartość domyślną oraz opis (w tej kolejności).
    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 uruchomieniu kodu powinieneś zobaczyć wynik podobny do:

TOOL CALL:  15
CONTENT:

AI przeanalizowało pytanie "Co to jest 3 + 12" i rozpoznało to jako zadanie dla narzędzia add. Podobnie jak doświadczony bibliotekarz wie, z którego źródła korzystać w zależności od pytania, podjęło tę decyzję na podstawie nazwy narzędzia, opisu i specyfikacji pól. Wynik 15 pochodzi ze słownika functions wykonującego narzędzie:

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

Bardziej interesujące narzędzie wywołujące API sieciowe

Dodawanie liczb ilustruje koncept, ale prawdziwe narzędzia zazwyczaj wykonują bardziej złożone operacje, takie jak wywoływanie API internetowych. Rozszerzmy nasz przykład tak, aby AI pobierało zawartość z internetu – podobnie jak operatorzy telegrafu kiedyś łączyli odległe lokalizacje:

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

    # Adnotacje muszą mieć typ i mogą opcjonalnie zawierać wartość domyślną oraz opis (w tej kolejności).
    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"

# reszta kodu jest taka sama

Teraz, jeśli uruchomisz ten kod, otrzymasz odpowiedź mówiącą coś w stylu:

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[Zapytanie użytkownika: "Opowiedz mi dowcip o zwierzętach"] --> B[Analiza LangChain]
    B --> C{Czy narzędzie jest dostępne?}
    C -->|Tak| D[Wybierz narzędzie do dowcipów]
    C -->|Nie| E[Wygeneruj bezpośrednią odpowiedź]
    
    D --> F[Wyodrębnij parametry]
    F --> G[Wywołaj dowcip(kategoria="zwierzęta")]
    G --> H[Żądanie API do chucknorris.io]
    H --> I[Zwróć treść dowcipu]
    I --> J[Wyświetl użytkownikowi]
    
    E --> K[Odpowiedź wygenerowana przez AI]
    K --> J
    
    subgraph "Warstwa definicji narzędzi"
        L[Schemat TypedDict]
        M[Implementacja funkcji]
        N[Walidacja parametrów]
    end
    
    D --> L
    F --> N
    G --> M

Oto kod w całości:

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

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

    # Adnotacje muszą mieć typ i mogą opcjonalnie zawierać wartość domyślną oraz opis (w tej kolejności).
    a: Annotated[int, ..., "First integer"]
    b: Annotated[int, ..., "Second integer"]

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

    # Adnotacje muszą mieć typ i mogą opcjonalnie zawierać wartość domyślną oraz opis (w tej kolejności).
    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("WYWOŁANIE NARZĘDZIA: ", tool)
        print("TOOL CALL: ", functions[tool["name"]](../../../10-ai-framework-project/**tool["args"]))
print("CONTENT: ",res.content)

Embeddingi i przetwarzanie dokumentów

Embeddingi to jedno z najpiękniejszych rozwiązań we współczesnej AI. Wyobraź sobie, że możesz wziąć dowolny kawałek tekstu i przekształcić go w współrzędne liczbowe, które uchwytują jego znaczenie. Właśnie to robią embeddingi – przekształcają tekst w punkty w przestrzeni wielowymiarowej, gdzie podobne koncepcje skupiają się razem. To jak system współrzędnych dla pomysłów, przypominający sposób, w jaki Mendelejew uporządkował układ okresowy według właściwości atomowych.

Tworzenie i używanie embeddingów

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

# Inicjalizuj osadzenia
embeddings = OpenAIEmbeddings(
    api_key=os.environ["GITHUB_TOKEN"],
    base_url="https://models.github.ai/inference",
    model="text-embedding-3-small"
)

# Załaduj i podziel dokumenty
loader = TextLoader("documentation.txt")
documents = loader.load()

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

# Utwórz magazyn wektorów
vectorstore = FAISS.from_documents(texts, embeddings)

# Wykonaj wyszukiwanie podobieństwa
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]}...")

Ładowarki dokumentów dla różnych formatów

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

# Załaduj różne typy dokumentów
pdf_loader = PyPDFLoader("manual.pdf")
csv_loader = CSVLoader("data.csv")
json_loader = JSONLoader("config.json")
web_loader = WebBaseLoader("https://example.com/docs")

# Przetwórz wszystkie dokumenty
all_documents = []
for loader in [pdf_loader, csv_loader, json_loader, web_loader]:
    docs = loader.load()
    all_documents.extend(docs)

Co możesz zrobić za pomocą embeddingów:

Zbudować wyszukiwanie, które naprawdę rozumie, co masz na myśli, a nie tylko dopasowanie słów kluczowych
Stworzyć AI, które potrafi odpowiadać na pytania dotyczące twoich dokumentów
Wykonać systemy rekomendacji sugerujące naprawdę istotne treści
Automatycznie organizować i kategoryzować twoje materiały

flowchart LR
    A[Dokumenty] --> B[Podział Tekstu]
    B --> C[Tworzenie Osadzeń]
    C --> D[Magazyn Wektorów]
    
    E[Zapytanie Użytkownika] --> F[Osadzenie Zapytania]
    F --> G[Wyszukiwanie Podobieństw]
    G --> D
    D --> H[Istotne Dokumenty]
    H --> I[Odpowiedź AI]
    
    subgraph "Przestrzeń Wektorowa"
        J[Dokument A: [0.1, 0.8, 0.3...]]
        K[Dokument B: [0.2, 0.7, 0.4...]]
        L[Zapytanie: [0.15, 0.75, 0.35...]]
    end
    
    C --> J
    C --> K
    F --> L
    G --> J
    G --> K

Budowanie kompletnej aplikacji AI

Teraz zintegrujemy wszystko, czego się nauczyłeś, w kompleksową aplikację – asystenta do programowania, który potrafi odpowiadać na pytania, korzystać z narzędzi i utrzymywać pamięć rozmowy. Podobnie jak druk łączył istniejące technologie (czcionki ruchome, tusz, papier i nacisk) w coś przełomowego, połączymy nasze komponenty AI w coś praktycznego i użytecznego.

Przykład kompletnej aplikacji

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.""")
        ]
        
        # Zdefiniuj narzędzia
        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):
        # Dodaj wiadomość użytkownika do rozmowy
        self.conversation_history.append(HumanMessage(content=user_input))
        
        # Pobierz odpowiedź AI
        response = self.llm_with_tools.invoke(self.conversation_history)
        
        # Obsłuż wywołania narzędzi, jeśli są
        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}")
        
        # Dodaj odpowiedź AI do rozmowy
        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"

# Przykład użycia
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 aplikacji:

graph TD
    A[Wejście użytkownika] --> B[Asystent kodowania]
    B --> C[Pamięć rozmowy]
    B --> D[Wykrywanie narzędzi]
    B --> E[Przetwarzanie LLM]
    
    D --> F[Narzędzie wyszukiwania w sieci]
    D --> G[Narzędzie formatowania kodu]
    
    E --> H[Generowanie odpowiedzi]
    F --> H
    G --> H
    
    H --> I[Interfejs użytkownika]
    H --> C

Kluczowe funkcje, które zaimplementowaliśmy:

Pamięta całą twoją rozmowę dla ciągłości kontekstu
Wykonuje działania poprzez wywoływanie narzędzi, nie tylko rozmowę
Podąża za przewidywalnymi wzorcami interakcji
Zarządza obsługą błędów i złożonymi procesami automatycznie

🎯 Pedagogiczne podsumowanie: Architektura AI produkcyjnego poziomu

Zrozumienie architektury: Zbudowałeś kompletną aplikację AI łączącą zarządzanie rozmową, wywoływanie narzędzi oraz zorganizowane procesy. To reprezentuje rozwój aplikacji AI na poziomie produkcyjnym.

Opanowane kluczowe koncepcje:

Architektura oparta na klasach: uporządkowana, łatwa do utrzymania struktura aplikacji AI
Integracja narzędzi: funkcjonalność niestandardowa wykraczająca poza rozmowę
Zarządzanie pamięcią: trwały kontekst konwersacji
Obsługa błędów: solidne zachowanie aplikacji

Powiązanie z branżą: Wzorce architektoniczne, które zaimplementowałeś (klasy rozmów, systemy narzędzi, zarządzanie pamięcią) to te same wzorce używane w korporacyjnych aplikacjach AI, takich jak asystent AI Slacka, GitHub Copilot czy Microsoft Copilot. Budujesz z myśleniem na profesjonalnym poziomie.

Pytanie do refleksji: Jak rozwiniesz tę aplikację, by obsługiwała wielu użytkowników, trwałą pamięć albo integrację z zewnętrznymi bazami danych? Weź pod uwagę wyzwania związane ze skalowalnością i zarządzaniem stanem.

Zadanie: Zbuduj własnego asystenta naukowego zasilanego AI

Cel: Stwórz aplikację AI, która pomoże studentom uczyć się programowania, dostarczając wyjaśnienia, przykłady kodu oraz interaktywne quizy.

Wymagania

Podstawowe funkcje (wymagane):

Interfejs rozmowy: Zaimplementuj system czatu, który zachowuje kontekst przez wiele pytań
Narzędzia edukacyjne: Stwórz co najmniej dwa narzędzia wspierające naukę:
- narzędzie do wyjaśniania kodu
- generator quizów koncepcyjnych
Spersonalizowane uczenie: Wykorzystaj komunikaty systemowe, by dostosować odpowiedzi do różnych poziomów zaawansowania
Formatowanie odpowiedzi: Zaimplementuj ustrukturyzowane wyjście dla pytań quizowych

Kroki wdrożenia

Krok 1: Przygotuj środowisko

pip install langchain langchain-openai

Krok 2: Podstawowa funkcjonalność czatu

Stwórz klasę StudyAssistant
Zaimplementuj pamięć rozmowy
Dodaj konfigurację osobowości dla wsparcia edukacyjnego

Krok 3: Dodaj narzędzia edukacyjne

Wyjaśniacz kodu: rozkłada kod na zrozumiałe części
Generator quizów: tworzy pytania dotyczące koncepcji programistycznych
Śledzenie postępów: monitoruje przerobione tematy

Krok 4: Rozszerzone funkcje (opcjonalnie)

Wdroż odpowiedzi strumieniowe dla lepszego doświadczenia użytkownika
Dodaj ładowanie dokumentów, aby uwzględnić materiały kursowe
Stwórz embeddingi do wyszukiwania semantycznego w materiałach

Kryteria oceny

Funkcja	Doskonała (4)	Dobra (3)	Zadowalająca (2)	Wymaga pracy (1)
Przebieg rozmowy	Naturalne, świadome kontekstu odpowiedzi	Dobra pamięć kontekstu	Podstawowa rozmowa	Brak pamięci między wymianami
Integracja narzędzi	Wiele użytecznych narzędzi działa bezproblemowo	2+ narzędzia poprawnie zaimplementowane	1-2 narzędzia podstawowe	Narzędzia nie działają
Jakość kodu	Czysty, dobrze udokumentowany, obsługa błędów	Dobra struktura, częściowa dokumentacja	Podstawowa funkcjonalność działa	Słaba struktura, brak obsługi błędów
Wartość edukacyjna	Naprawdę pomocne w nauce, adaptacyjne	Dobre wsparcie nauki	Podstawowe wyjaśnienia	Ograniczona wartość edukacyjna

Przykładowa struktura kodu

class StudyAssistant:
    def __init__(self, skill_level="beginner"):
        # Inicjalizuj LLM, narzędzia i pamięć konwersacji
        pass
    
    def explain_code(self, code, language):
        # Narzędzie: Wyjaśnij, jak działa kod
        pass
    
    def generate_quiz(self, topic, difficulty):
        # Narzędzie: Twórz pytania do ćwiczeń
        pass
    
    def chat(self, user_input):
        # Główne interfejs konwersacji
        pass

# Przykładowe użycie
assistant = StudyAssistant(skill_level="intermediate")
response = assistant.chat("Explain how Python functions work")

Dodatkowe wyzwania:

Dodaj obsługę wejścia/wyjścia głosowego
Wdroż interfejs webowy za pomocą Streamlit lub Flask
Stwórz bazę wiedzy z materiałów kursowych przy pomocy embeddingów
Dodaj śledzenie postępów i spersonalizowane ścieżki nauki

📈 Twoja oś mistrzostwa w rozwoju frameworków AI

timeline
    title Droga Rozwoju Produkcyjnego Frameworka AI
    
    section Fundamenty Frameworka
        Zrozumienie Abstrakcji
            : Decyzje dotyczące głównego frameworka vs API
            : Poznaj podstawowe koncepcje LangChain
            : Implementuj systemy typów wiadomości
        
        Podstawowa Integracja
            : Połącz z dostawcami AI
            : Obsłuż uwierzytelnianie
            : Zarządzaj konfiguracją
    
    section Systemy Konwersacyjne
        Zarządzanie Pamięcią
            : Buduj historię konwersacji
            : Implementuj śledzenie kontekstu
            : Obsłuż utrzymanie sesji
        
        Zaawansowane Interakcje
            : Opanuj strumieniowanie odpowiedzi
            : Twórz szablony promptów
            : Implementuj strukturalne wyniki
    
    section Integracja Narzędzi
        Tworzenie Niestandardowych Narzędzi
            : Projektuj schematy narzędzi
            : Implementuj wywołania funkcji
            : Obsłuż zewnętrzne API
        
        Automatyzacja Procesów
            : Łącz wiele narzędzi
            : Twórz drzewa decyzyjne
            : Buduj zachowania agentów
    
    section Aplikacje Produkcyjne
        Kompletną Architekturę Systemu
            : Połącz wszystkie funkcje frameworka
            : Implementuj granice błędów
            : Twórz łatwy do utrzymania kod
        
        Gotowość Przemysłowa
            : Zajmij się problemami skalowalności
            : Implementuj monitorowanie
            : Buduj strategie wdrażania

🎓 Kamień milowy ukończenia: Opanowałeś rozwój frameworków AI używając tych samych narzędzi i wzorców, które napędzają nowoczesne aplikacje AI. Te umiejętności reprezentują najnowszy poziom rozwoju aplikacji AI i przygotowują cię do budowy systemów inteligentnych na poziomie korporacyjnym.

🔄 Kolejne poziomy możliwości:

Gotowy do eksploracji zaawansowanych architektur AI (agenci, systemy multi-agentowe)
Przygotowany do budowy systemów RAG z bazami wektorowymi
Wyposażony, by tworzyć multimodalne aplikacje AI
Fundament pod skalowanie i optymalizację aplikacji AI

Podsumowanie

🎉 Opanowałeś podstawy rozwoju frameworków AI i nauczyłeś się, jak budować zaawansowane aplikacje AI używając LangChain. To jak ukończenie wszechstronnego praktykatu — zdobyłeś solidny zestaw umiejętności. Przejrzyjmy, co osiągnąłeś.

Czego się nauczyłeś

Podstawowe koncepcje frameworku:

Korzyści z frameworków: kiedy wybierać frameworki zamiast bezpośrednich wywołań API
Podstawy LangChain: konfiguracja i połączenie z modelami AI
Rodzaje wiadomości: stosowanie SystemMessage, HumanMessage i AIMessage dla uporządkowanych rozmów

Zaawansowane funkcje:

Wywoływanie narzędzi: tworzenie i integracja niestandardowych narzędzi zwiększających możliwości AI
Pamięć rozmowy: utrzymanie kontekstu przez wiele tur konwersacji
Streaming odpowiedzi: implementacja dostarczania odpowiedzi w czasie rzeczywistym
Szablony promptów: budowanie wielokrotnego użytku, dynamicznych promptów
Ustrukturyzowane wyjście: zapewnienie spójnych, łatwych do przetwarzania odpowiedzi AI
Embeddingi: tworzenie możliwości wyszukiwania semantycznego i przetwarzania dokumentów

Praktyczne zastosowania:

Budowanie kompletnej aplikacji: łączenie wielu funkcji w gotowe do produkcji aplikacje
Obsługa błędów: implementacja solidnego zarządzania błędami i walidacji
Integracja narzędzi: tworzenie własnych narzędzi rozszerzających możliwości AI

Kluczowe wnioski

🎯 Pamiętaj: Frameworki AI takie jak LangChain to twoi najlepsi przyjaciele ukrywający złożoność i oferujący wiele funkcji. Są idealne, gdy potrzebujesz pamięci rozmowy, wywoływania narzędzi lub chcesz pracować z wieloma modelami AI bez utraty zdrowia psychicznego.

Ramowy schemat decyzji przy integracji AI:

flowchart TD
    A[Potrzeba integracji AI] --> B{Proste pojedyncze zapytanie?}
    B -->|Tak| C[Bezpośrednie wywołania API]
    B -->|Nie| D{Potrzebna pamięć rozmowy?}
    D -->|Nie| E[Integracja SDK]
    D -->|Tak| F{Potrzebne narzędzia lub zaawansowane funkcje?}
    F -->|Nie| G[Framework z podstawową konfiguracją]
    F -->|Tak| H[Pełna implementacja frameworka]
    
    C --> I[Żądania HTTP, minimalne zależności]
    E --> J[SDK dostawcy, specyficzne dla modelu]
    G --> K[Podstawowy czat LangChain]
    H --> L[LangChain z narzędziami, pamięcią, agentami]

Co dalej?

Zacznij budować już teraz:

Weź te koncepcje i stwórz coś, co CIĘ ekscytuje!
Eksperymentuj z różnymi modelami AI przez LangChain – to jak plac zabaw pełen modeli AI
Twórz narzędzia rozwiązujące rzeczywiste problemy, z którymi się mierzasz w pracy lub projektach

Gotowy na kolejny poziom?

Agenci AI: Buduj systemy AI, które potrafią samodzielnie planować i wykonywać złożone zadania
RAG (retrieval-augmented generation): Połącz AI z własnymi bazami wiedzy dla supermocy aplikacji
Multimodalne AI: Pracuj jednocześnie z tekstem, obrazami i dźwiękiem – możliwości są nieograniczone!
Wdrożenie produkcyjne: Naucz się skalować aplikacje AI i monitorować je w rzeczywistym świecie

Dołącz do społeczności:

Społeczność LangChain jest fantastyczna do pozostania na bieżąco i nauki najlepszych praktyk
GitHub Models daje dostęp do najnowszych możliwości AI – idealne do eksperymentów
Ćwicz na różnych przypadkach użycia – każdy projekt nauczy cię czegoś nowego

Masz teraz wiedzę, by budować inteligentne, konwersacyjne aplikacje, które pomagają ludziom rozwiązywać prawdziwe problemy. Jak rzemieślnicy renesansu łączący wizję artystyczną z umiejętnościami technicznymi, możesz łączyć możliwości AI z praktycznym zastosowaniem. Pytanie brzmi: co stworzysz? 🚀

Wyzwanie GitHub Copilot Agent 🚀

Użyj trybu agenta, aby wykonać następujące wyzwanie:

Opis: Zbuduj zaawansowanego asystenta przeglądu kodu zasilanego AI, który łączy wiele funkcji LangChain, w tym wywoływanie narzędzi, ustrukturyzowane wyjście i pamięć rozmowy, by dostarczać kompleksowe opinie o przesłanych kodach.

Prompt: Stwórz klasę CodeReviewAssistant, która implementuje:

Narzędzie do analizy złożoności kodu i sugerowania ulepszeń
Narzędzie do sprawdzania kodu względem najlepszych praktyk
Ustrukturyzowane wyjście za pomocą modeli Pydantic dla spójnego formatu przeglądu
Pamięć rozmowy do śledzenia sesji przeglądu
Główny interfejs czatu obsługujący przesyłanie kodu i dostarczający szczegółowe, praktyczne uwagi

Asystent powinien potrafić recenzować kod w wielu językach programowania, utrzymywać kontekst przez wiele przesłanych fragmentów w sesji oraz dostarczać zarówno podsumowujące oceny, jak i szczegółowe sugestie ulepszeń.

Dowiedz się więcej o trybie agenta tutaj.

Zastrzeżenie: Niniejszy dokument został przetłumaczony za pomocą automatycznej usługi tłumaczeniowej AI Co-op Translator. Mimo że dążymy do dokładności, prosimy mieć na uwadze, że tłumaczenia automatyczne mogą zawierać błędy lub nieścisłości. Oryginalny dokument w języku źródłowym powinien być uznawany za wiarygodne źródło. W przypadku informacji istotnych zalecane jest skorzystanie z profesjonalnego tłumaczenia wykonanego przez człowieka. Nie ponosimy odpowiedzialności za jakiekolwiek nieporozumienia lub błędne interpretacje wynikające z korzystania z tego tłumaczenia.

48 KiB Raw Blame History Unescape Escape