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

AI-kehys

Oletko koskaan tuntenut olevasi hukassa yrittäessäsi rakentaa tekoälysovelluksia alusta alkaen? Et ole yksin! AI-kehykset ovat kuin monitoimityökalu tekoälykehitykseen – tehokkaita työkaluja, jotka säästävät aikaa ja vaivaa älykkäiden sovellusten rakentamisessa. Ajattele AI-kehystä hyvin organisoituna kirjastona: se tarjoaa valmiiksi rakennettuja komponentteja, standardoituja API-rajapintoja ja älykkäitä abstraktioita, jotta voit keskittyä ongelmien ratkaisemiseen sen sijaan, että kamppailisit toteutuksen yksityiskohtien kanssa.

Tässä oppitunnissa tutkimme, kuinka kehykset, kuten LangChain, voivat muuttaa aiemmin monimutkaiset tekoälyn integrointitehtävät selkeäksi ja helposti luettavaksi koodiksi. Opit ratkaisemaan todellisia haasteita, kuten keskustelujen seuraamista, työkalujen käyttöönottoa ja erilaisten tekoälymallien hallintaa yhden yhtenäisen käyttöliittymän kautta.

Kun oppitunti on ohi, tiedät, milloin kannattaa valita kehykset raakojen API-kutsujen sijaan, kuinka käyttää niiden abstraktioita tehokkaasti ja kuinka rakentaa tekoälysovelluksia, jotka ovat valmiita todelliseen käyttöön. Tutkitaan, mitä AI-kehykset voivat tehdä projekteillesi.

Miksi valita kehys?

Olet valmis rakentamaan tekoälysovelluksen – mahtavaa! Mutta tässä on juttu: sinulla on useita eri polkuja, joita voit kulkea, ja jokaisella on omat hyvät ja huonot puolensa. Se on vähän kuin valitsisit kävelyn, pyöräilyn tai ajamisen päästäksesi jonnekin – kaikki vievät sinut perille, mutta kokemus (ja vaivannäkö) on täysin erilainen.

Katsotaanpa kolmea pääasiallista tapaa integroida tekoäly projekteihisi:

Lähestymistapa	Edut	Paras käyttö	Huomioitavaa
Suorat HTTP-pyynnöt	Täysi hallinta, ei riippuvuuksia	Yksinkertaiset kyselyt, perusteiden oppiminen	Paljon koodia, manuaalinen virheenkäsittely
SDK-integraatio	Vähemmän boilerplate-koodia, mallikohtainen optimointi	Yksittäismalliset sovellukset	Rajoittuu tiettyihin tarjoajiin
AI-kehykset	Yhtenäinen API, sisäänrakennetut abstraktiot	Monimalliset sovellukset, monimutkaiset työnkulut	Oppimiskäyrä, mahdollinen yliabstraktio

Kehyksen hyödyt käytännössä

graph TD
    A[Your Application] --> B[AI Framework]
    B --> C[OpenAI GPT]
    B --> D[Anthropic Claude]
    B --> E[GitHub Models]
    B --> F[Local Models]
    
    B --> G[Built-in Tools]
    G --> H[Memory Management]
    G --> I[Conversation History]
    G --> J[Function Calling]
    G --> K[Error Handling]

Miksi kehykset ovat tärkeitä:

• Yhdistää useita tekoälypalveluntarjoajia yhteen käyttöliittymään
• Käsittelee keskustelumuistin automaattisesti
• Tarjoaa valmiita työkaluja yleisiin tehtäviin, kuten upotuksiin ja funktiokutsuihin
• Hallinnoi virheenkäsittelyä ja uudelleenkokeilulogiikkaa
• Muuttaa monimutkaiset työnkulut luettaviksi metodikutsuiksi

💡 Vinkki: Käytä kehyksiä, kun vaihdat eri tekoälymallien välillä tai rakennat monimutkaisia ominaisuuksia, kuten agentteja, muistia tai työkalujen käyttöä. Pysy suorissa API-kutsuissa, kun opettelet perusteita tai rakennat yksinkertaisia, keskittyneitä sovelluksia.

Yhteenveto: Kuten valinta erikoistyökalujen ja täydellisen työpajan välillä, kyse on työkalun sovittamisesta tehtävään. Kehykset loistavat monimutkaisissa, ominaisuusrikkaissa sovelluksissa, kun taas suorat API:t toimivat hyvin yksinkertaisissa käyttötapauksissa.

Johdanto

Tässä oppitunnissa opimme:

• Käyttämään yleistä AI-kehystä.
• Ratkaisemaan yleisiä ongelmia, kuten keskustelut, työkalujen käyttö, muisti ja konteksti.
• Hyödyntämään tätä tekoälysovellusten rakentamiseen.

Ensimmäinen tekoälykyselysi

Aloitetaan perusteista luomalla ensimmäinen tekoälysovellus, joka lähettää kysymyksen ja saa vastauksen. Kuten Arkhimedes, joka löysi syrjäytymisen periaatteen kylvyssään, joskus yksinkertaisimmat havainnot johtavat voimakkaimpiin oivalluksiin – ja kehykset tekevät nämä oivallukset helposti saavutettaviksi.

LangChainin käyttöönotto GitHub-mallien kanssa

Käytämme LangChainia yhdistääksemme GitHub-malleihin, mikä on aika siistiä, koska se antaa sinulle ilmaisen pääsyn erilaisiin tekoälymalleihin. Parasta? Tarvitset vain muutaman yksinkertaisen konfiguraatioparametrin aloittaaksesi:

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

# Send a simple prompt
response = llm.invoke("What's the capital of France?")
print(response.content)

Mitä tässä tapahtuu:

• Luo LangChain-asiakkaan ChatOpenAI-luokan avulla – tämä on porttisi tekoälyyn!
• Konfiguroi yhteyden GitHub-malleihin autentikointitunnuksellasi
• Määrittää käytettävän tekoälymallin (gpt-4o-mini) – ajattele tätä tekoälyavustajasi valintana
• Lähettää kysymyksesi invoke()-metodin avulla – tässä tapahtuu taikuus
• Poimii ja näyttää vastauksen – ja voilà, keskustelet tekoälyn kanssa!

🔧 Asennusvinkki: Jos käytät GitHub Codespacesia, sinulla on onnea – GITHUB_TOKEN on jo asetettu! Työskenteletkö paikallisesti? Ei hätää, sinun tarvitsee vain luoda henkilökohtainen pääsytunnus oikeilla käyttöoikeuksilla.

Odotettu tulos:

The capital of France is Paris.

sequenceDiagram
    participant App as Your Python App
    participant LC as LangChain
    participant GM as GitHub Models
    participant AI as GPT-4o-mini
    
    App->>LC: llm.invoke("What's the capital of France?")
    LC->>GM: HTTP request with prompt
    GM->>AI: Process prompt
    AI->>GM: Generated response
    GM->>LC: Return response
    LC->>App: response.content

Keskustelevan tekoälyn rakentaminen

Ensimmäinen esimerkki osoittaa perusteet, mutta se on vain yksi vaihto – kysyt kysymyksen, saat vastauksen, ja siinä se. Todellisissa sovelluksissa haluat, että tekoäly muistaa, mistä olette keskustelleet, kuten Watson ja Holmes rakensivat tutkimuskeskustelujaan ajan myötä.

Tässä LangChain on erityisen hyödyllinen. Se tarjoaa erilaisia viestityyppejä, jotka auttavat jäsentämään keskusteluja ja antavat sinulle mahdollisuuden antaa tekoälylle persoonallisuuden. Rakennat keskustelukokemuksia, jotka säilyttävät kontekstin ja luonteen.

Viestityyppien ymmärtäminen

Ajattele näitä viestityyppejä eri "hattuina", joita keskustelun osallistujat käyttävät. LangChain käyttää erilaisia viestiluokkia pitääkseen kirjaa siitä, kuka sanoo mitä:

Viestityyppi	Tarkoitus	Esimerkkikäyttö
SystemMessage	Määrittää tekoälyn persoonallisuuden ja käyttäytymisen	"Olet avulias koodausavustaja"
HumanMessage	Edustaa käyttäjän syötettä	"Selitä, miten funktiot toimivat"
AIMessage	Tallentaa tekoälyn vastaukset	Aiemmat tekoälyn vastaukset keskustelussa

Ensimmäisen keskustelun luominen

Luodaan keskustelu, jossa tekoäly ottaa tietyn roolin. Annetaan sen esittää kapteeni Picardia – hahmoa, joka tunnetaan diplomaattisesta viisaudestaan ja johtajuudestaan:

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

Tämän keskustelun asetusten purkaminen:

• Määrittää tekoälyn roolin ja persoonallisuuden SystemMessage-viestin kautta
• Tarjoaa käyttäjän alkuperäisen kyselyn HumanMessage-viestin kautta
• Luo perustan monivaiheiselle keskustelulle

Koko koodi tälle esimerkille näyttää tältä:

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


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

Näet tuloksen, joka näyttää tältä:

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?

Keskustelun jatkuvuuden ylläpitämiseksi (sen sijaan, että konteksti nollataan joka kerta), sinun täytyy lisätä vastaukset viestilistaan. Kuten suulliset perinteet, jotka säilyttivät tarinoita sukupolvien ajan, tämä lähestymistapa rakentaa pysyvän muistin:

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


# works
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)

Aika siistiä, eikö? Tässä tapahtuu se, että kutsumme LLM:ää kahdesti – ensin vain alkuperäisillä kahdella viestillä, mutta sitten uudelleen koko keskusteluhistorian kanssa. Se on kuin tekoäly todella seuraisi keskusteluamme!

Kun suoritat tämän koodin, saat toisen vastauksen, joka kuulostaa suunnilleen tältä:

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!

Otan tuon ehkä-vastauksena ;)

Vastausten suoratoisto

Oletko koskaan huomannut, kuinka ChatGPT "kirjoittaa" vastauksiaan reaaliajassa? Se on suoratoistoa toiminnassa. Kuten taitavan kalligrafin työskentelyä katsellessa – kun kirjaimet ilmestyvät viiva kerrallaan sen sijaan, että ne materialisoituisivat heti – suoratoisto tekee vuorovaikutuksesta luonnollisemman ja tarjoaa välitöntä palautetta.

Suoratoiston toteuttaminen LangChainilla

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
)

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

Miksi suoratoisto on mahtavaa:

• Näyttää sisällön sen luomisen aikana – ei enää kiusallista odottelua!
• Saa käyttäjät tuntemaan, että jotain tapahtuu
• Tuntuu nopeammalta, vaikka teknisesti ei olisikaan
• Antaa käyttäjien alkaa lukea, kun tekoäly vielä "ajattelee"

💡 Käyttäjäkokemusvinkki: Suoratoisto loistaa erityisesti, kun käsittelet pidempiä vastauksia, kuten koodiselityksiä, luovaa kirjoittamista tai yksityiskohtaisia oppaita. Käyttäjäsi rakastavat nähdä edistystä sen sijaan, että tuijottaisivat tyhjää ruutua!

Kehotemallit

Kehotemallit toimivat kuin retoriset rakenteet klassisessa puhetaidossa – ajattele, kuinka Cicero mukautti puhetyylinsä eri yleisöille säilyttäen saman vakuuttavan rakenteen. Niiden avulla voit luoda uudelleenkäytettäviä kehotteita, joissa voit vaihtaa eri tietoja ilman, että sinun tarvitsee kirjoittaa kaikkea uudelleen. Kun malli on asetettu, täytät vain muuttujat tarvittavilla arvoilla.

Uudelleenkäytettävien kehotteiden luominen

from langchain_core.prompts import ChatPromptTemplate

# Define a template for code explanations
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")
])

# Use the template with different values
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")

Miksi rakastat mallien käyttöä:

• Pitää kehotteesi johdonmukaisina koko sovelluksessa
• Ei enää sotkuista merkkijonojen yhdistelyä – vain siistejä, yksinkertaisia muuttujia
• Tekoälysi käyttäytyy ennustettavasti, koska rakenne pysyy samana
• Päivitykset ovat helppoja – muuta mallia kerran, ja se on korjattu kaikkialla

Jäsennelty ulostulo

Oletko koskaan turhautunut yrittäessäsi jäsentää tekoälyn vastauksia, jotka palaavat jäsentämättömänä tekstinä? Jäsennelty ulostulo on kuin opettaisit tekoälyä noudattamaan systemaattista lähestymistapaa, kuten Linnaeus käytti biologisessa luokittelussa – järjestelmällistä, ennustettavaa ja helppoa työstää. Voit pyytää JSON-muotoa, tiettyjä tietorakenteita tai mitä tahansa tarvitsemaasi muotoa.

Ulostulokaavioiden määrittäminen

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

# Set up the parser
parser = JsonOutputParser(pydantic_object=CodeReview)

# Create prompt with format instructions
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a code reviewer. {format_instructions}"),
    ("human", "Review this code: {code}")
])

# Format the prompt with instructions
chain = prompt | llm | parser

# Get structured response
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'])}")

Miksi jäsennelty ulostulo on mullistava:

• Ei enää arvailua, missä muodossa vastaus tulee – se on aina johdonmukainen
• Sopii suoraan tietokantoihisi ja API-rajapintoihisi ilman lisätyötä
• Havaitsee oudot tekoälyvastaukset ennen kuin ne rikkovat sovelluksesi
• Tekee koodistasi siistimmän, koska tiedät tarkalleen, mitä käsittelet

Työkalujen käyttö

Nyt pääsemme yhteen tehokkaimmista ominaisuuksista: työkalut. Näin annat tekoälyllesi käytännön kykyjä keskustelun ulkopuolella. Kuten keskiaikaiset killat kehittivät erikoistyökaluja tiettyihin käsityöaloihin, voit varustaa tekoälysi keskittyneillä välineillä. Kuvailet, mitkä työkalut ovat käytettävissä, ja kun joku pyytää jotain vastaavaa, tekoäly voi toimia.

Pythonin käyttö

Lisätään joitakin työkaluja näin:

from typing_extensions import Annotated, TypedDict

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

    # Annotations must have the type and can optionally include a default value and description (in that order).
    a: Annotated[int, ..., "First integer"]
    b: Annotated[int, ..., "Second integer"]

tools = [add]

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

Mitä tässä tapahtuu? Luomme työkalulle nimeltä add suunnitelman. Perimällä TypedDict-luokasta ja käyttämällä hienoja Annotated-tyyppejä a ja b-kentille, annamme LLM:lle selkeän kuvan siitä, mitä tämä työkalu tekee ja mitä se tarvitsee. functions-sanakirja on kuin työkalupakkimme – se kertoo koodillemme tarkalleen, mitä tehdä, kun tekoäly päättää käyttää tiettyä työkalua.

Katsotaanpa, kuinka kutsumme LLM:ää tämän työkalun kanssa seuraavaksi:

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)

Tässä kutsumme bind_tools-metodia tools-taulukolla, ja näin LLM llm_with_tools tuntee tämän työkalun.

Käyttääksemme tätä uutta LLM:ää voimme kirjoittaa seuraavan koodin:

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)

Kun kutsumme invoke-metodia tähän uuteen LLM:ään, jolla on työkaluja, ominaisuus tool_calls saattaa täyttyä. Jos näin tapahtuu, tunnistetut työkalut sisältävät name- ja args-ominaisuudet, jotka tunnistavat, mitä työkalua tulisi käyttää ja millä argumenteilla. Koko koodi näyttää tältä:

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

    # Annotations must have the type and can optionally include a default value and description (in that order).
    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)

Kun suoritat tämän koodin, näet tuloksen, joka näyttää tältä:

TOOL CALL:  15
CONTENT: 

Tekoäly tutki "Mikä on 3 + 12" ja tunnisti tämän tehtäväksi add-työkalulle. Kuten taitava kirjastonhoitaja tietää, mihin viitteeseen turvautua kysymyksen tyypin perusteella, tekoäly teki tämän päätelmän työkalun nimen, kuvauksen ja kenttämäärittelyjen perusteella. Tulos 15 tulee functions-sanakirjastamme, joka suorittaa työkalun:

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

Mielenkiintoisempi työkalu, joka kutsuu verkkosovellusliittymää

Lukujen lisääminen havainnollistaa konseptia, mutta todelliset työkalut suorittavat yleensä monimutkaisempia operaatioita, kuten verkkosovellusliittymien kutsumista. Laajennetaan esimerkkiamme niin, että tekoäly hakee sisältöä internetistä – kuten kuinka lennätinoperaattorit kerran yhdistivät kaukaisia paikkoja:

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

    # Annotations must have the type and can optionally include a default value and description (in that order).
    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"

# the rest of the code is the same

Kun suoritat tämän koodin, saat vastauksen, joka sanoo jotain tällaista:

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

Tässä on koodi kokonaisuudessaan:

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

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

    # Annotations must have the type and can optionally include a default value and description (in that order).
    a: Annotated[int, ..., "First integer"]
    b: Annotated[int, ..., "Second integer"]

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

    # Annotations must have the type and can optionally include a default value and description (in that order).
    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("TOOL CALL: ", tool)
        print("TOOL CALL: ", functions[tool["name"]](../../../10-ai-framework-project/**tool["args"]))
print("CONTENT: ",res.content)

Upotukset ja dokumenttien käsittely

Upotukset edustavat yhtä modernin tekoälyn elegantimmista ratkaisuista. Kuvittele, että voisit ottaa minkä tahansa tekstin ja muuttaa sen numeerisiksi koordinaateiksi, jotka vangitsevat sen merkityksen. Juuri näin upotukset toimivat – ne muuntavat tekstin pisteiksi moniulotteisessa avaruudessa, jossa samankaltaiset käsitteet ryhmittyvät yhteen. Se on kuin ideakoordinaatistojärjestelmä, joka muistuttaa, kuinka Mendelejev järjesti jaksollisen järjestelmän atomisten ominaisuuksien mukaan.

Upotusten luominen ja käyttö

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

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

# Load and split documents
loader = TextLoader("documentation.txt")
documents = loader.load()

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

# Create vector store
vectorstore = FAISS.from_documents(texts, embeddings)

# Perform similarity search
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]}...")

Dokumenttien lataajat eri formaateille

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

# Load different document types
pdf_loader = PyPDFLoader("manual.pdf")
csv_loader = CSVLoader("data.csv")
json_loader = JSONLoader("config.json")
web_loader = WebBaseLoader("https://example.com/docs")

# Process all documents
all_documents = []
for loader in [pdf_loader, csv_loader, json_loader, web_loader]:
    docs = loader.load()
    all_documents.extend(docs)

Mitä voit tehdä upotuksilla:

• Rakenna haku, joka todella ymmärtää, mitä tarkoitat, ei vain avainsanoja
• Luo tekoäly, joka voi vastata kysymyksiin dokumenteistasi
• Tee suositusjärjestelmiä, jotka ehdottavat todella relevanttia sisältöä
• Järjestä ja luokittele sisältösi automaattisesti

Täydellisen tekoälysovelluksen rakentaminen

Nyt integro 3. Personoitu oppiminen: Käytä järjestelmäviestejä mukauttamaan vastauksia eri taitotasoille
4. Vastausten muotoilu: Toteuta rakenteellinen ulostulo visailukysymyksille

Toteutusvaiheet

Vaihe 1: Ympäristön asennus

pip install langchain langchain-openai

Vaihe 2: Perustoiminnallisuus keskustelulle

• Luo StudyAssistant-luokka
• Toteuta keskustelumuisti
• Lisää persoonallisuusasetukset opetustukea varten

Vaihe 3: Lisää opetusvälineet

• Koodin selitys: Jakaa koodin ymmärrettäviin osiin
• Visailugeneraattori: Luo kysymyksiä ohjelmointikonsepteista
• Edistymisen seuranta: Seuraa käsiteltyjä aiheita

Vaihe 4: Parannellut ominaisuudet (valinnainen)

• Toteuta suoratoistovastaukset paremman käyttäjäkokemuksen takaamiseksi
• Lisää dokumenttien lataus kurssimateriaalien sisällyttämiseksi
• Luo upotuksia sisältöjen samankaltaisuuteen perustuvaa hakua varten

Arviointikriteerit

Ominaisuus	Erinomainen (4)	Hyvä (3)	Tyydyttävä (2)	Parannettavaa (1)
Keskustelun kulku	Luonnolliset, kontekstitietoiset vastaukset	Hyvä kontekstin säilyttäminen	Peruskeskustelu	Ei muistia vaihdoista
Työkalujen integrointi	Useita hyödyllisiä työkaluja toimivat saumattomasti	2+ työkalua toteutettu oikein	1-2 perustyökalua	Työkalut eivät toimi
Koodin laatu	Siisti, hyvin dokumentoitu, virheenkäsittely	Hyvä rakenne, jonkin verran dokumentointia	Perustoiminnallisuus toimii	Huono rakenne, ei virheenkäsittelyä
Opetuksellinen arvo	Todella hyödyllinen oppimiseen, mukautuva	Hyvä oppimistuki	Perusselitykset	Rajoitettu opetuksellinen hyöty

Esimerkkikoodirakenne

class StudyAssistant:
    def __init__(self, skill_level="beginner"):
        # Initialize LLM, tools, and conversation memory
        pass
    
    def explain_code(self, code, language):
        # Tool: Explain how code works
        pass
    
    def generate_quiz(self, topic, difficulty):
        # Tool: Create practice questions
        pass
    
    def chat(self, user_input):
        # Main conversation interface
        pass

# Example usage
assistant = StudyAssistant(skill_level="intermediate")
response = assistant.chat("Explain how Python functions work")

Bonushaasteet:

• Lisää ääni sisään/ulos -ominaisuudet
• Toteuta verkkokäyttöliittymä Streamlitin tai Flaskin avulla
• Luo tietopohja kurssimateriaaleista upotusten avulla
• Lisää edistymisen seuranta ja personoidut oppimispolut

Yhteenveto

🎉 Olet nyt hallinnut AI-kehyskehityksen perusteet ja oppinut rakentamaan kehittyneitä AI-sovelluksia LangChainin avulla. Kuten kattavan oppisopimuskoulutuksen suorittanut, olet hankkinut merkittävän työkalupakin taitoja. Katsotaanpa, mitä olet saavuttanut.

Mitä olet oppinut

Kehyksen peruskäsitteet:

• Kehyksen edut: Ymmärrys siitä, milloin valita kehykset suoran API-kutsun sijaan
• LangChainin perusteet: AI-malliyhteyksien asennus ja konfigurointi
• Viestityypit: SystemMessage, HumanMessage ja AIMessage rakenteellisiin keskusteluihin

Kehittyneet ominaisuudet:

• Työkalujen kutsuminen: Mukautettujen työkalujen luominen ja integrointi AI:n kykyjen parantamiseksi
• Keskustelumuisti: Kontekstin säilyttäminen useiden keskustelukierrosten ajan
• Suoratoistovastaukset: Reaaliaikaisen vastaustoimituksen toteuttaminen
• Kehotemallit: Uudelleenkäytettävien, dynaamisten kehotteiden rakentaminen
• Rakenteellinen ulostulo: Johdonmukaisten, jäsennettävien AI-vastausten varmistaminen
• Upotukset: Semanttisen haun ja dokumenttien käsittelyominaisuuksien luominen

Käytännön sovellukset:

• Täydellisten sovellusten rakentaminen: Useiden ominaisuuksien yhdistäminen tuotantovalmiisiin sovelluksiin
• Virheenkäsittely: Vankan virheiden hallinnan ja validoinnin toteuttaminen
• Työkalujen integrointi: Mukautettujen työkalujen luominen AI:n kykyjen laajentamiseksi

Keskeiset opit

🎯 Muista: AI-kehykset, kuten LangChain, ovat käytännössä monimutkaisuutta piilottavia, ominaisuuksilla täytettyjä parhaita ystäviäsi. Ne ovat täydellisiä, kun tarvitset keskustelumuistia, työkalujen kutsumista tai haluat työskennellä useiden AI-mallien kanssa menettämättä järkeäsi.

Päätöksentekokehys AI-integraatiolle:

flowchart TD
    A[AI Integration Need] --> B{Simple single query?}
    B -->|Yes| C[Direct API calls]
    B -->|No| D{Need conversation memory?}
    D -->|No| E[SDK Integration]
    D -->|Yes| F{Need tools or complex features?}
    F -->|No| G[Framework with basic setup]
    F -->|Yes| H[Full framework implementation]
    
    C --> I[HTTP requests, minimal dependencies]
    E --> J[Provider SDK, model-specific]
    G --> K[LangChain basic chat]
    H --> L[LangChain with tools, memory, agents]

Mihin tästä eteenpäin?

Aloita rakentaminen heti:

• Hyödynnä näitä käsitteitä ja rakenna jotain, mikä innostaa SINUA!
• Kokeile erilaisia AI-malleja LangChainin avulla - se on kuin AI-mallien leikkikenttä
• Luo työkaluja, jotka ratkaisevat todellisia ongelmia työssäsi tai projekteissasi

Valmis seuraavalle tasolle?

• AI-agentit: Rakenna AI-järjestelmiä, jotka voivat suunnitella ja toteuttaa monimutkaisia tehtäviä itsenäisesti
• RAG (Retrieval-Augmented Generation): Yhdistä AI omiin tietopohjiisi supertehokkaiden sovellusten luomiseksi
• Monimodaalinen AI: Työskentele tekstin, kuvien ja äänen kanssa yhdessä - mahdollisuudet ovat rajattomat!
• Tuotantokäyttöön ottaminen: Opi skaalaamaan AI-sovelluksesi ja seuraamaan niitä tosielämässä

Liity yhteisöön:

• LangChain-yhteisö on loistava pysyäksesi ajan tasalla ja oppiaksesi parhaita käytäntöjä
• GitHub Models tarjoaa pääsyn huippuluokan AI-ominaisuuksiin - täydellinen kokeiluun
• Jatka harjoittelua eri käyttötapauksilla - jokainen projekti opettaa sinulle jotain uutta

Nyt sinulla on tiedot rakentaa älykkäitä, keskustelukykyisiä sovelluksia, jotka voivat auttaa ihmisiä ratkaisemaan todellisia ongelmia. Kuten renessanssin käsityöläiset, jotka yhdistivät taiteellisen vision tekniseen taitoon, voit nyt yhdistää AI-kyvyt käytännön sovelluksiin. Kysymys kuuluu: mitä sinä luot? 🚀

GitHub Copilot Agent -haaste 🚀

Käytä Agent-tilaa suorittaaksesi seuraavan haasteen:

Kuvaus: Rakenna kehittynyt AI-pohjainen koodin tarkistusassistentti, joka yhdistää useita LangChain-ominaisuuksia, mukaan lukien työkalujen kutsuminen, rakenteellinen ulostulo ja keskustelumuisti, tarjotakseen kattavaa palautetta koodin lähetyksistä.

Kehote: Luo CodeReviewAssistant-luokka, joka toteuttaa:

1. Työkalu koodin monimutkaisuuden analysointiin ja parannusehdotusten antamiseen
2. Työkalu koodin tarkistamiseen parhaita käytäntöjä vastaan
3. Rakenteellinen ulostulo Pydantic-mallien avulla johdonmukaisen tarkistusmuodon varmistamiseksi
4. Keskustelumuisti tarkistussessioiden seuraamiseksi
5. Pääasiallinen keskustelukäyttöliittymä, joka voi käsitellä koodin lähetyksiä ja tarjota yksityiskohtaista, toimivaa palautetta

Assistentin tulisi pystyä tarkistamaan koodia useilla ohjelmointikielillä, säilyttämään konteksti useiden koodilähetysten välillä samassa sessiossa ja tarjoamaan sekä yhteenvetopisteitä että yksityiskohtaisia parannusehdotuksia.

Lisätietoja agent mode täällä.

---

Vastuuvapauslauseke:
Tämä asiakirja on käännetty käyttämällä tekoälypohjaista käännöspalvelua Co-op Translator. Vaikka pyrimme tarkkuuteen, huomioithan, että automaattiset käännökset voivat sisältää virheitä tai epätarkkuuksia. Alkuperäinen asiakirja sen alkuperäisellä kielellä tulisi pitää ensisijaisena lähteenä. Kriittisen tiedon osalta suositellaan ammattimaista ihmiskäännöstä. Emme ole vastuussa väärinkäsityksistä tai virhetulkinnoista, jotka johtuvat tämän käännöksen käytöstä.