Selle põhiosas LangChain on uuenduslik raamistik, mis on kohandatud keelemudelite võimalusi võimendavate rakenduste loomiseks. See on tööriistakomplekt, mis on mõeldud arendajatele, et luua rakendusi, mis on kontekstiteadlikud ja suudavad keerukalt arutleda.
See tähendab, et LangChaini rakendused saavad aru kontekstist, nagu viipejuhised või sisupõhised vastused, ja kasutada keelemudeleid keeruliste arutlusülesannete jaoks, näiteks otsustada, kuidas vastata või milliseid toiminguid teha. LangChain esindab ühtset lähenemist intelligentsete rakenduste arendamisele, lihtsustades oma erinevate komponentidega teekonda kontseptsioonist teostuseni.
LangChaini mõistmine
LangChain on palju enamat kui lihtsalt raamistik; see on täisväärtuslik ökosüsteem, mis koosneb mitmest lahutamatust osast.
- Esiteks on olemas LangChaini teegid, mis on saadaval nii Pythonis kui ka JavaScriptis. Need teegid on LangChaini selgroog, pakkudes liideseid ja integratsioone erinevate komponentide jaoks. Need pakuvad põhilist käitusaega nende komponentide ühendamiseks sidusateks ahelateks ja agentideks koos valmisrakendustega koheseks kasutamiseks.
- Järgmiseks on meil LangChaini mallid. Need on juurutatavate võrdlusarhitektuuride kogum, mis on kohandatud paljude ülesannete jaoks. Olenemata sellest, kas loote vestlusrobotit või keerukat analüüsitööriista, pakuvad need mallid kindla lähtepunkti.
- LangServe astub mitmekülgse raamatukoguna kasutusele LangChaini kettide REST API-dena juurutamiseks. See tööriist on hädavajalik teie LangChaini projektide muutmiseks juurdepääsetavateks ja skaleeritavateks veebiteenusteks.
- Lõpuks toimib LangSmith arendajaplatvormina. See on loodud mis tahes LLM-raamistikule ehitatud kettide silumiseks, testimiseks, hindamiseks ja jälgimiseks. Sujuv integreerimine LangChainiga muudab selle asendamatuks tööriistaks arendajatele, kes soovivad oma rakendusi täiustada ja täiustada.
Need komponendid koos annavad teile võimaluse rakendusi hõlpsalt arendada, toota ja juurutada. LangChainiga alustate rakenduste kirjutamisest teekide abil, viidates juhiste saamiseks mallidele. Seejärel aitab LangSmith teil ahelaid kontrollida, testida ja jälgida, tagades teie rakenduste pideva täiustamise ja juurutamiseks valmisoleku. Lõpuks saate LangServe'iga hõlpsalt muuta mis tahes ahela API-ks, muutes juurutamise imelihtsaks.
Järgmistes osades uurime põhjalikumalt, kuidas LangChaini seadistada ja alustame oma teekonda intelligentsete, keelemudelitel põhinevate rakenduste loomisel.
Automatiseerige käsitsi ülesandeid ja töövooge meie AI-põhise töövoo koostajaga, mille on välja töötanud Nanonets teile ja teie meeskondadele.
Paigaldamine ja seadistamine
Kas olete valmis sukelduma LangChaini maailma? Selle seadistamine on lihtne ja see juhend juhendab teid selles protsessis samm-sammult.
LangChaini teekonna esimene samm on selle installimine. Seda saate hõlpsalt teha pipi või conda abil. Käivitage terminalis järgmine käsk:
pip install langchain
Need, kes eelistavad uusimaid funktsioone ja tunnevad end veidi rohkem seiklustest, saate installida LangChaini otse allikast. Kloonige hoidla ja navigeerige saidile langchain/libs/langchain
kataloog. Seejärel käivitage:
pip install -e .
Katsefunktsioonide jaoks kaaluge installimist langchain-experimental
. See on pakett, mis sisaldab tipptasemel koodi ning on mõeldud uurimis- ja eksperimenteerimiseks. Installige see kasutades:
pip install langchain-experimental
LangChain CLI on mugav tööriist LangChaini mallide ja LangServe projektidega töötamiseks. LangChaini CLI installimiseks kasutage:
pip install langchain-cli
LangServe on teie LangChaini kettide REST API-na juurutamiseks hädavajalik. See installitakse koos LangChain CLI-ga.
LangChain nõuab sageli integreerimist mudelipakkujate, andmehoidlate, API-dega jne. Selle näite puhul kasutame OpenAI mudeli API-sid. Installige OpenAI Pythoni pakett, kasutades:
pip install openai
API-le juurdepääsuks määrake oma OpenAI API võti keskkonnamuutujaks.
export OPENAI_API_KEY="your_api_key"
Teise võimalusena edastage võti otse oma pythoni keskkonnas:
import os
os.environ['OPENAI_API_KEY'] = 'your_api_key'
LangChain võimaldab moodulite kaudu luua keelemudeli rakendusi. Need moodulid võivad olla eraldiseisvad või koostatud keerukate kasutusjuhtude jaoks. Need moodulid on -
- Mudel I/O: hõlbustab suhtlemist erinevate keelemudelitega, käsitledes tõhusalt nende sisendeid ja väljundeid.
- Väljatoomine: võimaldab juurdepääsu rakendusepõhistele andmetele ja nendega suhtlemist, mis on andmete dünaamilise kasutamise jaoks ülioluline.
- Agendid: Võimaldage rakendusi valida sobivaid tööriistu kõrgetasemeliste direktiivide alusel, suurendades otsustusvõimet.
- Ketid: pakub eelmääratletud korduvkasutatavaid kompositsioone, mis toimivad rakenduste arendamise ehitusplokkidena.
- Mälu: Säilitab rakenduse oleku mitme ahela täitmise ajal, mis on kontekstiteadliku interaktsiooni jaoks oluline.
Iga moodul on suunatud konkreetsetele arendusvajadustele, muutes LangChainis tervikliku tööriistakomplekti täiustatud keelemudeli rakenduste loomiseks.
Lisaks ülaltoodud komponentidele on meil ka LangChaini väljenduskeel (LCEL), mis on deklaratiivne viis moodulite hõlpsaks koostamiseks ja see võimaldab komponentide aheldamist universaalse Runnable-liidese abil.
LCEL näeb välja umbes selline –
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema import BaseOutputParser # Example chain
chain = ChatPromptTemplate() | ChatOpenAI() | CustomOutputParser()
Nüüd, kui oleme põhitõed käsitlenud, jätkame:
- Süvenege igasse Langchaini moodulisse üksikasjalikumalt.
- Siit saate teada, kuidas kasutada LangChaini väljenduskeelt.
- Uurige levinumaid kasutusjuhtumeid ja rakendage neid.
- Juurutage täielik rakendus LangServe'iga.
- Silumiseks, testimiseks ja jälgimiseks vaadake LangSmithi.
Hakkame pihta!
I moodul: I/O mudel
LangChainis keerleb iga rakenduse põhielement keelemudeli ümber. See moodul pakub olulisi ehitusplokke tõhusaks liidestamiseks mis tahes keelemudeliga, tagades sujuva integratsiooni ja suhtluse.
Mudeli I/O põhikomponendid
- LLM-id ja vestlusmudelid (kasutatakse vaheldumisi):
- LLM-id:
- Määratlus: puhtad teksti lõpetamise mudelid.
- Input / Output: võtke sisendiks tekstistring ja tagastage väljundina tekstistring.
- Vestlusmudelid
- LLM-id:
- Määratlus: mudelid, mis kasutavad alusena keelemudelit, kuid erinevad sisend- ja väljundvormingute poolest.
- Input / Output: aktsepteerige vestlussõnumite loendit sisendina ja tagastage vestlussõnum.
- Palub: mallistage, dünaamiliselt valige ja hallake mudelisisendeid. Võimaldab luua paindlikke ja kontekstispetsiifilisi viipasid, mis suunavad keelemudeli vastuseid.
- Väljundparserid: teabe väljavõte ja vormindamine mudeli väljunditest. Kasulik keelemudelite toorväljundi teisendamiseks struktureeritud andmeteks või konkreetseteks vorminguteks, mida rakendus vajab.
LLM-id
LangChaini integreerimine suurte keelemudelitega (LLM), nagu OpenAI, Cohere ja Hugging Face, on selle funktsionaalsuse põhiaspekt. LangChain ise ei majuta LLM-e, kuid pakub ühtset liidest erinevate LLM-idega suhtlemiseks.
See jaotis annab ülevaate OpenAI LLM-i ümbrise kasutamisest LangChainis, mis on kohaldatav ka teistele LLM-tüüpidele. Oleme selle juba installinud jaotisesse "Alustamine". Initsialiseerime LLM-i.
from langchain.llms import OpenAI
llm = OpenAI()
- LLM-id rakendavad Töötav liides, selle peamine ehitusplokk LangChaini väljenduskeel (LCEL). See tähendab, et nad toetavad
invoke
,ainvoke
,stream
,astream
,batch
,abatch
,astream_log
kõned. - LLM-id aktsepteerivad stringid sisenditena või objektidena, mida saab sundida stringiviipadele, sealhulgas
List[BaseMessage]
jaPromptValue
. (nendest lähemalt hiljem)
Vaatame mõnda näidet.
response = llm.invoke("List the seven wonders of the world.")
print(response)
Teise võimalusena saate tekstivastuse voogesitamiseks helistada voomeetodile.
for chunk in llm.stream("Where were the 2012 Olympics held?"): print(chunk, end="", flush=True)
Vestlusmudelid
LangChaini integreerimine vestlusmudelitega, mis on keelemudelite spetsiaalne variatsioon, on interaktiivsete vestlusrakenduste loomiseks hädavajalik. Kuigi nad kasutavad keelemudeleid sisemiselt, pakuvad vestlusmudelid selget liidest, mis on keskendunud vestlussõnumitele sisenditena ja väljunditena. See jaotis annab üksikasjaliku ülevaate OpenAI vestlusmudeli kasutamisest LangChainis.
from langchain.chat_models import ChatOpenAI
chat = ChatOpenAI()
LangChaini vestlusmudelid töötavad erinevate sõnumitüüpidega, näiteks AIMessage
, HumanMessage
, SystemMessage
, FunctionMessage
ja ChatMessage
(suvalise rolliparameetriga). Üldiselt HumanMessage
, AIMessage
ja SystemMessage
on kõige sagedamini kasutatavad.
Vestlusmudelid aktsepteerivad peamiselt List[BaseMessage]
sisenditena. Stringe saab teisendada HumanMessage
ja PromptValue
on ka toetatud.
from langchain.schema.messages import HumanMessage, SystemMessage
messages = [ SystemMessage(content="You are Micheal Jordan."), HumanMessage(content="Which shoe manufacturer are you associated with?"),
]
response = chat.invoke(messages)
print(response.content)
Palub
Viibad on olulised keelemudelite suunamisel asjakohaste ja sidusate väljundite loomiseks. Need võivad ulatuda lihtsatest juhistest kuni keerukate mõne kaadriga näideteni. LangChainis võib viipade käsitlemine olla väga sujuv protsess tänu mitmele spetsiaalsele klassile ja funktsioonile.
LangChaini oma PromptTemplate
klass on mitmekülgne tööriist stringiviipade loomiseks. See kasutab Pythoni str.format
süntaks, mis võimaldab dünaamilist viipade genereerimist. Saate määrata kohahoidjatega malli ja täita need vastavalt vajadusele konkreetsete väärtustega.
from langchain.prompts import PromptTemplate # Simple prompt with placeholders
prompt_template = PromptTemplate.from_template( "Tell me a {adjective} joke about {content}."
) # Filling placeholders to create a prompt
filled_prompt = prompt_template.format(adjective="funny", content="robots")
print(filled_prompt)
Vestlusmudelite puhul on viibad struktureeritumad, hõlmates kindla rolliga sõnumeid. LangChain pakub ChatPromptTemplate
Selleks otstarbeks.
from langchain.prompts import ChatPromptTemplate # Defining a chat prompt with various roles
chat_template = ChatPromptTemplate.from_messages( [ ("system", "You are a helpful AI bot. Your name is {name}."), ("human", "Hello, how are you doing?"), ("ai", "I'm doing well, thanks!"), ("human", "{user_input}"), ]
) # Formatting the chat prompt
formatted_messages = chat_template.format_messages(name="Bob", user_input="What is your name?")
for message in formatted_messages: print(message)
See lähenemisviis võimaldab luua interaktiivseid, kaasahaaravaid dünaamiliste vastustega vestlusroboteid.
Mõlemad PromptTemplate
ja ChatPromptTemplate
integreeruvad sujuvalt LangChain Expression Language'iga (LCEL), võimaldades neil olla osa suurematest ja keerukatest töövoogudest. Me arutame seda hiljem rohkem.
Kohandatud viipade mallid on mõnikord hädavajalikud ülesannete jaoks, mis nõuavad ainulaadset vormingut või konkreetseid juhiseid. Kohandatud viipamalli loomine hõlmab sisendmuutujate ja kohandatud vormindamismeetodi määratlemist. See paindlikkus võimaldab LangChainil täita paljusid rakendusespetsiifilisi nõudeid. Loe lähemalt siit.
LangChain toetab ka mõne võttega viipasid, võimaldades mudelil näidetest õppida. See funktsioon on oluline ülesannete jaoks, mis nõuavad konteksti mõistmist või konkreetseid mustreid. Vähese pildiga viipamalle saab luua näidete komplektist või näidisvalija objekti abil. Loe lähemalt siit.
Väljundparserid
Väljundparserid mängivad Langchainis üliolulist rolli, võimaldades kasutajatel struktureerida keelemudelite genereeritud vastuseid. Selles jaotises uurime väljundparserite kontseptsiooni ja pakume koodinäiteid, kasutades Langchaini PydanticOutputParser, SimpleJsonOutputParser, CommaSeparatedListOutputParser, DatetimeOutputParser ja XMLOutputParser.
PydanticOutputParser
Langchain pakub PydanticOutputParseri vastuste Pydantic andmestruktuuridesse sõelumiseks. Allpool on samm-sammult näide selle kasutamisest:
from typing import List
from langchain.llms import OpenAI
from langchain.output_parsers import PydanticOutputParser
from langchain.prompts import PromptTemplate
from langchain.pydantic_v1 import BaseModel, Field, validator # Initialize the language model
model = OpenAI(model_name="text-davinci-003", temperature=0.0) # Define your desired data structure using Pydantic
class Joke(BaseModel): setup: str = Field(description="question to set up a joke") punchline: str = Field(description="answer to resolve the joke") @validator("setup") def question_ends_with_question_mark(cls, field): if field[-1] != "?": raise ValueError("Badly formed question!") return field # Set up a PydanticOutputParser
parser = PydanticOutputParser(pydantic_object=Joke) # Create a prompt with format instructions
prompt = PromptTemplate( template="Answer the user query.n{format_instructions}n{query}n", input_variables=["query"], partial_variables={"format_instructions": parser.get_format_instructions()},
) # Define a query to prompt the language model
query = "Tell me a joke." # Combine prompt, model, and parser to get structured output
prompt_and_model = prompt | model
output = prompt_and_model.invoke({"query": query}) # Parse the output using the parser
parsed_result = parser.invoke(output) # The result is a structured object
print(parsed_result)
Väljundiks on:
SimpleJsonOutputParser
Langchaini SimpleJsonOutputParserit kasutatakse siis, kui soovite sõeluda JSON-i sarnaseid väljundeid. Siin on näide:
from langchain.output_parsers.json import SimpleJsonOutputParser # Create a JSON prompt
json_prompt = PromptTemplate.from_template( "Return a JSON object with `birthdate` and `birthplace` key that answers the following question: {question}"
) # Initialize the JSON parser
json_parser = SimpleJsonOutputParser() # Create a chain with the prompt, model, and parser
json_chain = json_prompt | model | json_parser # Stream through the results
result_list = list(json_chain.stream({"question": "When and where was Elon Musk born?"})) # The result is a list of JSON-like dictionaries
print(result_list)
CommaSeparatedListOutputParser
CommaSeparatedListOutputParser on mugav, kui soovite mudeli vastustest komadega eraldatud loendeid eraldada. Siin on näide:
from langchain.output_parsers import CommaSeparatedListOutputParser
from langchain.prompts import PromptTemplate
from langchain.llms import OpenAI # Initialize the parser
output_parser = CommaSeparatedListOutputParser() # Create format instructions
format_instructions = output_parser.get_format_instructions() # Create a prompt to request a list
prompt = PromptTemplate( template="List five {subject}.n{format_instructions}", input_variables=["subject"], partial_variables={"format_instructions": format_instructions}
) # Define a query to prompt the model
query = "English Premier League Teams" # Generate the output
output = model(prompt.format(subject=query)) # Parse the output using the parser
parsed_result = output_parser.parse(output) # The result is a list of items
print(parsed_result)
DatetimeOutputParser
Langchaini DatetimeOutputParser on loodud kuupäeva ja kellaaja teabe sõelumiseks. Kasutage seda järgmiselt.
from langchain.prompts import PromptTemplate
from langchain.output_parsers import DatetimeOutputParser
from langchain.chains import LLMChain
from langchain.llms import OpenAI # Initialize the DatetimeOutputParser
output_parser = DatetimeOutputParser() # Create a prompt with format instructions
template = """
Answer the user's question:
{question}
{format_instructions} """ prompt = PromptTemplate.from_template( template, partial_variables={"format_instructions": output_parser.get_format_instructions()},
) # Create a chain with the prompt and language model
chain = LLMChain(prompt=prompt, llm=OpenAI()) # Define a query to prompt the model
query = "when did Neil Armstrong land on the moon in terms of GMT?" # Run the chain
output = chain.run(query) # Parse the output using the datetime parser
parsed_result = output_parser.parse(output) # The result is a datetime object
print(parsed_result)
Need näited näitavad, kuidas Langchaini väljundparsereid saab kasutada erinevat tüüpi mudelivastuste struktureerimiseks, muutes need sobivaks erinevate rakenduste ja vormingute jaoks. Väljundparserid on väärtuslik tööriist keelemudeli väljundite kasutatavuse ja tõlgendatavuse parandamiseks Langchainis.
Automatiseerige käsitsi ülesandeid ja töövooge meie AI-põhise töövoo koostajaga, mille on välja töötanud Nanonets teile ja teie meeskondadele.
II moodul: väljavõte
Otsimine LangChainis mängib üliolulist rolli rakendustes, mis nõuavad kasutajaspetsiifilisi andmeid, mis ei sisaldu mudeli koolituskomplektis. See protsess, mida tuntakse Retrieval Augmented Generation (RAG) nime all, hõlmab välisandmete toomist ja nende integreerimist keelemudeli genereerimisprotsessi. LangChain pakub selle protsessi hõlbustamiseks laiaulatuslikku tööriistade ja funktsioonide komplekti, mis pakub nii lihtsaid kui ka keerukaid rakendusi.
LangChain saavutab otsimise mitmete komponentide kaudu, mida arutame ükshaaval.
Dokumendilaadijad
LangChaini dokumendilaadurid võimaldavad hankida andmeid erinevatest allikatest. Kuna saadaval on üle 100 laadija, toetavad need mitmesuguseid dokumenditüüpe, rakendusi ja allikaid (privaatsed s3 ämbrid, avalikud veebisaidid, andmebaasid).
Saate valida dokumendilaaduri vastavalt oma vajadustele siin.
Kõik need laadijad neelavad andmeid sisse Dokument klassid. Dokumendiklassidesse sisestatud andmeid õpime hiljem kasutama.
Tekstifaili laadija: Laadige lihtne .txt
faili dokumenti.
from langchain.document_loaders import TextLoader loader = TextLoader("./sample.txt")
document = loader.load()
CSV-laadija: Laadige CSV-fail dokumenti.
from langchain.document_loaders.csv_loader import CSVLoader loader = CSVLoader(file_path='./example_data/sample.csv')
documents = loader.load()
Saame parsimist kohandada, määrates väljade nimed -
loader = CSVLoader(file_path='./example_data/mlb_teams_2012.csv', csv_args={ 'delimiter': ',', 'quotechar': '"', 'fieldnames': ['MLB Team', 'Payroll in millions', 'Wins']
})
documents = loader.load()
PDF-laadijad: LangChaini PDF-laadurid pakuvad erinevaid meetodeid PDF-failide sisu sõelumiseks ja nendest väljavõtmiseks. Iga laadija vastab erinevatele nõuetele ja kasutab erinevaid aluseks olevaid teeke. Allpool on üksikasjalikud näited iga laaduri kohta.
PyPDFLoaderit kasutatakse lihtsaks PDF-i parsimiseks.
from langchain.document_loaders import PyPDFLoader loader = PyPDFLoader("example_data/layout-parser-paper.pdf")
pages = loader.load_and_split()
MathPixLoader sobib ideaalselt matemaatilise sisu ja diagrammide eraldamiseks.
from langchain.document_loaders import MathpixPDFLoader loader = MathpixPDFLoader("example_data/math-content.pdf")
data = loader.load()
PyMuPDFLoader on kiire ja sisaldab üksikasjalikku metaandmete ekstraheerimist.
from langchain.document_loaders import PyMuPDFLoader loader = PyMuPDFLoader("example_data/layout-parser-paper.pdf")
data = loader.load() # Optionally pass additional arguments for PyMuPDF's get_text() call
data = loader.load(option="text")
PDFMiner Loaderit kasutatakse teksti ekstraheerimise täpsemaks kontrollimiseks.
from langchain.document_loaders import PDFMinerLoader loader = PDFMinerLoader("example_data/layout-parser-paper.pdf")
data = loader.load()
AmazonTextractPDFParser kasutab OCR-i jaoks AWS Textracti ja muid täiustatud PDF-i sõelumise funktsioone.
from langchain.document_loaders import AmazonTextractPDFLoader # Requires AWS account and configuration
loader = AmazonTextractPDFLoader("example_data/complex-layout.pdf")
documents = loader.load()
PDFMinerPDFasHTMLLoader genereerib semantilise analüüsi jaoks PDF-ist HTML-i.
from langchain.document_loaders import PDFMinerPDFasHTMLLoader loader = PDFMinerPDFasHTMLLoader("example_data/layout-parser-paper.pdf")
data = loader.load()
PDFPlumberLoader pakub üksikasjalikke metaandmeid ja toetab ühte dokumenti lehekülje kohta.
from langchain.document_loaders import PDFPlumberLoader loader = PDFPlumberLoader("example_data/layout-parser-paper.pdf")
data = loader.load()
Integreeritud laadurid: LangChain pakub laias valikus kohandatud laadijaid, et laadida andmeid otse teie rakendustest (nt Slack, Sigma, Notion, Confluence, Google Drive ja palju muud) ja andmebaasidest ning kasutada neid LLM-i rakendustes.
Täielik nimekiri on siin.
Allpool on paar näidet selle illustreerimiseks -
Näide I – lõtv
Slacki, laialdaselt kasutatav kiirsuhtlusplatvorm, saab integreerida LLM-i töövoogudesse ja rakendustesse.
- Minge lehele Slack Workspace Management.
- Liigu
{your_slack_domain}.slack.com/services/export
. - Valige soovitud kuupäevavahemik ja alustage eksporti.
- Slack teavitab meili ja DM-i teel, kui eksport on valmis.
- Ekspordi tulemuseks on a
.zip
faili, mis asub kaustas Allalaadimised või määratud allalaadimisteel. - Määrake allalaaditava tee
.zip
toimikuleLOCAL_ZIPFILE
. - Kasuta
SlackDirectoryLoader
alateslangchain.document_loaders
pakendis.
from langchain.document_loaders import SlackDirectoryLoader SLACK_WORKSPACE_URL = "https://xxx.slack.com" # Replace with your Slack URL
LOCAL_ZIPFILE = "" # Path to the Slack zip file loader = SlackDirectoryLoader(LOCAL_ZIPFILE, SLACK_WORKSPACE_URL)
docs = loader.load()
print(docs)
Näide II – Figma
Figma, populaarne liidese kujundamise tööriist, pakub andmete integreerimiseks REST API-d.
- Hankige Figma failivõti URL-i vormingust:
https://www.figma.com/file/{filekey}/sampleFilename
. - Sõlme ID-d leiate URL-i parameetrist
?node-id={node_id}
. - Looge juurdepääsuluba, järgides juhiseid aadressil Figma abikeskus.
- .
FigmaFileLoader
klassist alateslangchain.document_loaders.figma
kasutatakse Figma andmete laadimiseks. - Erinevad LangChaini moodulid nagu
CharacterTextSplitter
,ChatOpenAI
jne, kasutatakse töötlemiseks.
import os
from langchain.document_loaders.figma import FigmaFileLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain.chat_models import ChatOpenAI
from langchain.indexes import VectorstoreIndexCreator
from langchain.chains import ConversationChain, LLMChain
from langchain.memory import ConversationBufferWindowMemory
from langchain.prompts.chat import ChatPromptTemplate, SystemMessagePromptTemplate, AIMessagePromptTemplate, HumanMessagePromptTemplate figma_loader = FigmaFileLoader( os.environ.get("ACCESS_TOKEN"), os.environ.get("NODE_IDS"), os.environ.get("FILE_KEY"),
) index = VectorstoreIndexCreator().from_loaders([figma_loader])
figma_doc_retriever = index.vectorstore.as_retriever()
- .
generate_code
funktsioon kasutab Figma andmeid HTML/CSS-koodi loomiseks. - See kasutab mallivestlust GPT-põhise mudeliga.
def generate_code(human_input): # Template for system and human prompts system_prompt_template = "Your coding instructions..." human_prompt_template = "Code the {text}. Ensure it's mobile responsive" # Creating prompt templates system_message_prompt = SystemMessagePromptTemplate.from_template(system_prompt_template) human_message_prompt = HumanMessagePromptTemplate.from_template(human_prompt_template) # Setting up the AI model gpt_4 = ChatOpenAI(temperature=0.02, model_name="gpt-4") # Retrieving relevant documents relevant_nodes = figma_doc_retriever.get_relevant_documents(human_input) # Generating and formatting the prompt conversation = [system_message_prompt, human_message_prompt] chat_prompt = ChatPromptTemplate.from_messages(conversation) response = gpt_4(chat_prompt.format_prompt(context=relevant_nodes, text=human_input).to_messages()) return response # Example usage
response = generate_code("page top header")
print(response.content)
- .
generate_code
funktsioon tagastab käivitamisel HTML/CSS-koodi, mis põhineb Figma disainisisendil.
Kasutagem nüüd oma teadmisi mõne dokumendikomplekti loomiseks.
Esmalt laadime PDF-faili, BCG iga-aastase jätkusuutlikkuse aruande.
Selleks kasutame PyPDFLoaderit.
from langchain.document_loaders import PyPDFLoader loader = PyPDFLoader("bcg-2022-annual-sustainability-report-apr-2023.pdf")
pdfpages = loader.load_and_split()
Neelame nüüd Airtable'i andmeid. Meil on õhutabel, mis sisaldab teavet erinevate OCR-i ja andmete eraldamise mudelite kohta -
Kasutage selleks AirtableLoaderit, mille leiate integreeritud laadurite loendist.
from langchain.document_loaders import AirtableLoader api_key = "XXXXX"
base_id = "XXXXX"
table_id = "XXXXX" loader = AirtableLoader(api_key, table_id, base_id)
airtabledocs = loader.load()
Jätkame nüüd ja õpime neid dokumendiklasse kasutama.
Dokumendi transformerid
LangChaini dokumenditrafod on olulised tööriistad, mis on loodud dokumentidega manipuleerimiseks, mille lõime eelmises alajaotises.
Neid kasutatakse selliste ülesannete jaoks nagu pikkade dokumentide jagamine väiksemateks tükkideks, kombineerimine ja filtreerimine, mis on üliolulised dokumentide kohandamiseks mudeli kontekstiaknaga või konkreetsete rakendusvajaduste rahuldamiseks.
Üks selline tööriist on RecursiveCharacterTextSplitter, mitmekülgne tekstijaotur, mis kasutab tükeldamiseks märgiloendit. See võimaldab selliseid parameetreid nagu tüki suurus, kattumine ja algusindeks. Siin on näide selle kohta, kuidas seda Pythonis kasutatakse:
from langchain.text_splitter import RecursiveCharacterTextSplitter state_of_the_union = "Your long text here..." text_splitter = RecursiveCharacterTextSplitter( chunk_size=100, chunk_overlap=20, length_function=len, add_start_index=True,
) texts = text_splitter.create_documents([state_of_the_union])
print(texts[0])
print(texts[1])
Teine tööriist on CharacterTextSplitter, mis jaotab teksti määratud tähemärgi alusel ja sisaldab tüki suuruse ja kattumise juhtelemente:
from langchain.text_splitter import CharacterTextSplitter text_splitter = CharacterTextSplitter( separator="nn", chunk_size=1000, chunk_overlap=200, length_function=len, is_separator_regex=False,
) texts = text_splitter.create_documents([state_of_the_union])
print(texts[0])
HTMLHeaderTextSplitter on loodud HTML-i sisu jagamiseks päise siltide alusel, säilitades semantilise struktuuri:
from langchain.text_splitter import HTMLHeaderTextSplitter html_string = "Your HTML content here..."
headers_to_split_on = [("h1", "Header 1"), ("h2", "Header 2")] html_splitter = HTMLHeaderTextSplitter(headers_to_split_on=headers_to_split_on)
html_header_splits = html_splitter.split_text(html_string)
print(html_header_splits[0])
Keerulisema manipuleerimise saab saavutada, kombineerides HTMLHeaderTextSplitterit mõne muu jaoturiga, näiteks konveieriga:
from langchain.text_splitter import HTMLHeaderTextSplitter, RecursiveCharacterTextSplitter url = "https://example.com"
headers_to_split_on = [("h1", "Header 1"), ("h2", "Header 2")]
html_splitter = HTMLHeaderTextSplitter(headers_to_split_on=headers_to_split_on)
html_header_splits = html_splitter.split_text_from_url(url) chunk_size = 500
text_splitter = RecursiveCharacterTextSplitter(chunk_size=chunk_size)
splits = text_splitter.split_documents(html_header_splits)
print(splits[0])
LangChain pakub ka spetsiaalseid jagajaid erinevate programmeerimiskeelte jaoks, nagu Pythoni koodijagaja ja JavaScripti koodijagaja:
from langchain.text_splitter import RecursiveCharacterTextSplitter, Language python_code = """
def hello_world(): print("Hello, World!")
hello_world() """ python_splitter = RecursiveCharacterTextSplitter.from_language( language=Language.PYTHON, chunk_size=50
)
python_docs = python_splitter.create_documents([python_code])
print(python_docs[0]) js_code = """
function helloWorld() { console.log("Hello, World!");
}
helloWorld(); """ js_splitter = RecursiveCharacterTextSplitter.from_language( language=Language.JS, chunk_size=60
)
js_docs = js_splitter.create_documents([js_code])
print(js_docs[0])
Teksti jagamiseks märkide arvu alusel, mis on kasulik märgipiirangutega keelemudelite jaoks, kasutatakse TokenTextSplitterit:
from langchain.text_splitter import TokenTextSplitter text_splitter = TokenTextSplitter(chunk_size=10)
texts = text_splitter.split_text(state_of_the_union)
print(texts[0])
Lõpuks korraldab LongContextReorder dokumendid ümber, et vältida mudelite jõudluse halvenemist pikkade kontekstide tõttu:
from langchain.document_transformers import LongContextReorder reordering = LongContextReorder()
reordered_docs = reordering.transform_documents(docs)
print(reordered_docs[0])
Need tööriistad näitavad erinevaid viise dokumentide teisendamiseks LangChainis, alates lihtsast teksti tükeldamisest kuni keeruka ümberjärjestamise ja keelepõhise tükeldamiseni. Põhjalikumate ja spetsiifilisemate kasutusjuhtude jaoks tuleks tutvuda LangChaini dokumentatsiooni ja integratsioonide jaotisega.
Meie näidetes on laadijad juba loonud meie jaoks tükeldatud dokumendid ja see osa on juba käsitletud.
Teksti manustamise mudelid
LangChaini teksti manustamismudelid pakuvad standardiseeritud liidest erinevatele manustamismudelite pakkujatele, nagu OpenAI, Cohere ja Hugging Face. Need mudelid muudavad teksti vektoresitusteks, võimaldades selliseid toiminguid nagu semantiline otsing teksti sarnasuse kaudu vektorruumis.
Teksti manustamismudelitega alustamiseks peate tavaliselt installima konkreetsed paketid ja seadistama API võtmed. Oleme seda OpenAI jaoks juba teinud
LangChainis on embed_documents
meetodit kasutatakse mitme teksti manustamiseks, pakkudes vektoresitluste loendit. Näiteks:
from langchain.embeddings import OpenAIEmbeddings # Initialize the model
embeddings_model = OpenAIEmbeddings() # Embed a list of texts
embeddings = embeddings_model.embed_documents( ["Hi there!", "Oh, hello!", "What's your name?", "My friends call me World", "Hello World!"]
)
print("Number of documents embedded:", len(embeddings))
print("Dimension of each embedding:", len(embeddings[0]))
Ühe teksti (nt otsingupäringu) manustamiseks kasutage embed_query
meetodit kasutatakse. See on kasulik päringu võrdlemiseks dokumendi manustamiskomplektiga. Näiteks:
from langchain.embeddings import OpenAIEmbeddings # Initialize the model
embeddings_model = OpenAIEmbeddings() # Embed a single query
embedded_query = embeddings_model.embed_query("What was the name mentioned in the conversation?")
print("First five dimensions of the embedded query:", embedded_query[:5])
Nende manuste mõistmine on ülioluline. Iga tekstiosa teisendatakse vektoriks, mille mõõde sõltub kasutatavast mudelist. Näiteks OpenAI mudelid toodavad tavaliselt 1536-mõõtmelisi vektoreid. Neid manuseid kasutatakse seejärel asjakohase teabe hankimiseks.
LangChaini manustamisfunktsioonid ei piirdu OpenAI-ga, vaid on loodud töötama erinevate pakkujatega. Seadistamine ja kasutamine võivad olenevalt pakkujast veidi erineda, kuid tekstide vektorruumi manustamise põhikontseptsioon jääb samaks. Üksikasjalikuks kasutamiseks, sealhulgas täiustatud konfiguratsioonideks ja integreerimiseks erinevate manustamismudelite pakkujatega, on LangChaini dokumentatsioon jaotises Integratsioonid väärtuslik ressurss.
Vektorikauplused
LangChaini vektorpoed toetavad teksti manuste tõhusat salvestamist ja otsimist. LangChain integreerub enam kui 50 vektorpoega, pakkudes kasutusmugavuseks standardiseeritud liidest.
Näide: Manuste salvestamine ja otsimine
Pärast tekstide manustamist saame need salvestada vektorpoodi nagu Chroma
ja teostage sarnasuse otsinguid:
from langchain.vectorstores import Chroma db = Chroma.from_texts(embedded_texts)
similar_texts = db.similarity_search("search query")
Alternatiivina kasutame oma dokumentide jaoks indeksite loomiseks FAISS-i vektorpoodi.
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import FAISS pdfstore = FAISS.from_documents(pdfpages, embedding=OpenAIEmbeddings()) airtablestore = FAISS.from_documents(airtabledocs, embedding=OpenAIEmbeddings())
Retriiverid
LangChaini retriiverid on liidesed, mis tagastavad dokumendid vastuseks struktureerimata päringule. Need on üldisemad kui vektorpoed, keskendudes pigem otsimisele kui salvestamisele. Kuigi vektoripoode saab kasutada retriiveri selgroona, on ka teist tüüpi retriivereid.
Chroma retriiveri seadistamiseks installige see esmalt kasutades pip install chromadb
. Seejärel laadite, jagate, manustage ja laadite dokumente Pythoni käskude seeria abil. Siin on koodinäide Chroma retriiveri seadistamiseks:
from langchain.embeddings import OpenAIEmbeddings
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores import Chroma full_text = open("state_of_the_union.txt", "r").read()
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
texts = text_splitter.split_text(full_text) embeddings = OpenAIEmbeddings()
db = Chroma.from_texts(texts, embeddings)
retriever = db.as_retriever() retrieved_docs = retriever.invoke("What did the president say about Ketanji Brown Jackson?")
print(retrieved_docs[0].page_content)
MultiQueryRetriever automatiseerib viipade häälestamise, genereerides kasutaja sisestatud päringu jaoks mitu päringut ja kombineerides tulemused. Siin on näide selle lihtsast kasutamisest:
from langchain.chat_models import ChatOpenAI
from langchain.retrievers.multi_query import MultiQueryRetriever question = "What are the approaches to Task Decomposition?"
llm = ChatOpenAI(temperature=0)
retriever_from_llm = MultiQueryRetriever.from_llm( retriever=db.as_retriever(), llm=llm
) unique_docs = retriever_from_llm.get_relevant_documents(query=question)
print("Number of unique documents:", len(unique_docs))
Kontekstuaalne pakkimine LangChainis tihendab otsitud dokumendid päringu konteksti kasutades, tagades, et tagastatakse ainult asjakohane teave. See hõlmab sisu vähendamist ja vähem asjakohaste dokumentide filtreerimist. Järgmine koodinäide näitab, kuidas kasutada kontekstipõhise tihendamise retriiverit:
from langchain.llms import OpenAI
from langchain.retrievers import ContextualCompressionRetriever
from langchain.retrievers.document_compressors import LLMChainExtractor llm = OpenAI(temperature=0)
compressor = LLMChainExtractor.from_llm(llm)
compression_retriever = ContextualCompressionRetriever(base_compressor=compressor, base_retriever=retriever) compressed_docs = compression_retriever.get_relevant_documents("What did the president say about Ketanji Jackson Brown")
print(compressed_docs[0].page_content)
EnsembleRetriever kombineerib parema jõudluse saavutamiseks erinevaid otsingualgoritme. Näide BM25 ja FAISS retriiverite kombineerimisest on näidatud järgmises koodis:
from langchain.retrievers import BM25Retriever, EnsembleRetriever
from langchain.vectorstores import FAISS bm25_retriever = BM25Retriever.from_texts(doc_list).set_k(2)
faiss_vectorstore = FAISS.from_texts(doc_list, OpenAIEmbeddings())
faiss_retriever = faiss_vectorstore.as_retriever(search_kwargs={"k": 2}) ensemble_retriever = EnsembleRetriever( retrievers=[bm25_retriever, faiss_retriever], weights=[0.5, 0.5]
) docs = ensemble_retriever.get_relevant_documents("apples")
print(docs[0].page_content)
LangChaini MultiVector Retriiver võimaldab teha päringuid dokumentide kohta mitme vektoriga dokumendi kohta, mis on kasulik dokumendi erinevate semantiliste aspektide jäädvustamiseks. Mitme vektori loomise meetodid hõlmavad jagamist väiksemateks tükkideks, kokkuvõtete tegemist või hüpoteetiliste küsimuste genereerimist. Dokumentide jagamiseks väiksemateks tükkideks saab kasutada järgmist Pythoni koodi:
python
from langchain.retrievers.multi_vector import MultiVectorRetriever
from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.storage import InMemoryStore
from langchain.document_loaders from TextLoader
import uuid loaders = [TextLoader("file1.txt"), TextLoader("file2.txt")]
docs = [doc for loader in loaders for doc in loader.load()]
text_splitter = RecursiveCharacterTextSplitter(chunk_size=10000)
docs = text_splitter.split_documents(docs) vectorstore = Chroma(collection_name="full_documents", embedding_function=OpenAIEmbeddings())
store = InMemoryStore()
id_key = "doc_id"
retriever = MultiVectorRetriever(vectorstore=vectorstore, docstore=store, id_key=id_key) doc_ids = [str(uuid.uuid4()) for _ in docs]
child_text_splitter = RecursiveCharacterTextSplitter(chunk_size=400)
sub_docs = [sub_doc for doc in docs for sub_doc in child_text_splitter.split_documents([doc])]
for sub_doc in sub_docs: sub_doc.metadata[id_key] = doc_ids[sub_docs.index(sub_doc)] retriever.vectorstore.add_documents(sub_docs)
retriever.docstore.mset(list(zip(doc_ids, docs)))
Teiseks meetodiks on kokkuvõtete loomine paremaks otsimiseks tänu rohkem keskendunud sisu esitusele. Siin on näide kokkuvõtete loomisest:
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.document import Document chain = (lambda x: x.page_content) | ChatPromptTemplate.from_template("Summarize the following document:nn{doc}") | ChatOpenAI(max_retries=0) | StrOutputParser()
summaries = chain.batch(docs, {"max_concurrency": 5}) summary_docs = [Document(page_content=s, metadata={id_key: doc_ids[i]}) for i, s in enumerate(summaries)]
retriever.vectorstore.add_documents(summary_docs)
retriever.docstore.mset(list(zip(doc_ids, docs)))
Teine lähenemisviis on LLM-i abil iga dokumendi jaoks asjakohaste hüpoteetiliste küsimuste genereerimine. Seda saab teha järgmise koodiga:
functions = [{"name": "hypothetical_questions", "parameters": {"questions": {"type": "array", "items": {"type": "string"}}}}]
from langchain.output_parsers.openai_functions import JsonKeyOutputFunctionsParser chain = (lambda x: x.page_content) | ChatPromptTemplate.from_template("Generate 3 hypothetical questions:nn{doc}") | ChatOpenAI(max_retries=0).bind(functions=functions, function_call={"name": "hypothetical_questions"}) | JsonKeyOutputFunctionsParser(key_name="questions")
hypothetical_questions = chain.batch(docs, {"max_concurrency": 5}) question_docs = [Document(page_content=q, metadata={id_key: doc_ids[i]}) for i, questions in enumerate(hypothetical_questions) for q in questions]
retriever.vectorstore.add_documents(question_docs)
retriever.docstore.mset(list(zip(doc_ids, docs)))
Vanemdokumendi retriiver on veel üks retriiver, mis loob tasakaalu manustamise täpsuse ja konteksti säilitamise vahel, salvestades väikesed tükid ja hankides nende suuremad põhidokumendid. Selle rakendamine on järgmine:
from langchain.retrievers import ParentDocumentRetriever loaders = [TextLoader("file1.txt"), TextLoader("file2.txt")]
docs = [doc for loader in loaders for doc in loader.load()] child_splitter = RecursiveCharacterTextSplitter(chunk_size=400)
vectorstore = Chroma(collection_name="full_documents", embedding_function=OpenAIEmbeddings())
store = InMemoryStore()
retriever = ParentDocumentRetriever(vectorstore=vectorstore, docstore=store, child_splitter=child_splitter) retriever.add_documents(docs, ids=None) retrieved_docs = retriever.get_relevant_documents("query")
Isepäringuga retriiver koostab loomuliku keele sisenditest struktureeritud päringuid ja rakendab need oma aluseks olevas VectorStore'is. Selle rakendamine on näidatud järgmises koodis:
from langchain.chat_models from ChatOpenAI
from langchain.chains.query_constructor.base from AttributeInfo
from langchain.retrievers.self_query.base from SelfQueryRetriever metadata_field_info = [AttributeInfo(name="genre", description="...", type="string"), ...]
document_content_description = "Brief summary of a movie"
llm = ChatOpenAI(temperature=0) retriever = SelfQueryRetriever.from_llm(llm, vectorstore, document_content_description, metadata_field_info) retrieved_docs = retriever.invoke("query")
WebResearchRetriever teostab veebiuuringuid antud päringu alusel –
from langchain.retrievers.web_research import WebResearchRetriever # Initialize components
llm = ChatOpenAI(temperature=0)
search = GoogleSearchAPIWrapper()
vectorstore = Chroma(embedding_function=OpenAIEmbeddings()) # Instantiate WebResearchRetriever
web_research_retriever = WebResearchRetriever.from_llm(vectorstore=vectorstore, llm=llm, search=search) # Retrieve documents
docs = web_research_retriever.get_relevant_documents("query")
Meie näidete jaoks saame kasutada ka standardset retriiverit, mis on juba meie vektorite salvestamise objekti osana rakendatud järgmiselt:
Nüüd saame retriiverite kohta päringuid teha. Meie päringu väljundiks on päringu jaoks asjakohased dokumendiobjektid. Neid kasutatakse lõpuks asjakohaste vastuste loomiseks järgmistes jaotistes.
Automatiseerige käsitsi ülesandeid ja töövooge meie AI-põhise töövoo koostajaga, mille on välja töötanud Nanonets teile ja teie meeskondadele.
III moodul: agendid
LangChain tutvustab võimsat kontseptsiooni nimega "Agents", mis viib kettide idee täiesti uuele tasemele. Agendid kasutavad keelemudeleid, et määrata dünaamiliselt sooritatavate toimingute jadasid, muutes need uskumatult mitmekülgseteks ja kohanemisvõimelisteks. Erinevalt traditsioonilistest kettidest, kus toimingud on koodis kõvasti kodeeritud, kasutavad agendid arutlusmootoritena keelemudeleid, et otsustada, milliseid toiminguid teha ja millises järjekorras.
Agent on otsustamise eest vastutav põhikomponent. See kasutab ära keelemudeli võimsust ja viipa, et määrata kindlaks järgmised sammud konkreetse eesmärgi saavutamiseks. Agendi sisendid hõlmavad tavaliselt järgmist:
- Vahendid: Saadaolevate tööriistade kirjeldused (sellest lähemalt hiljem).
- Kasutaja sisend: Kõrgetasemeline eesmärk või kasutaja päring.
- Vaheetapid: Praeguse kasutaja sisendini jõudmiseks käivitatud (toimingu, tööriista väljundi) paaride ajalugu.
Agendi väljund võib olla järgmine tegevus tegutsema (AgentActions) või finaal vastus kasutajale saatmiseks (AgentFinish). An tegevus täpsustab a tööriist ja sisend selle tööriista jaoks.
TÖÖRIISTAD
Tööriistad on liidesed, mida agent saab kasutada maailmaga suhtlemiseks. Need võimaldavad agentidel täita erinevaid ülesandeid, näiteks otsida veebist, käivitada shellikäske või pääseda juurde välistele API-dele. LangChainis on tööriistad olulised agentide võimaluste laiendamiseks ja erinevate ülesannete täitmiseks.
LangChainis tööriistade kasutamiseks saate need laadida järgmise koodilõigu abil:
from langchain.agents import load_tools tool_names = [...]
tools = load_tools(tool_names)
Mõned tööriistad võivad vajada lähtestamiseks baaskeelemudelit (LLM). Sellistel juhtudel saate läbida ka LLM-i:
from langchain.agents import load_tools tool_names = [...]
llm = ...
tools = load_tools(tool_names, llm=llm)
See seadistus võimaldab teil pääseda juurde mitmesugustele tööriistadele ja integreerida need oma agendi töövoogudesse. Tööriistade täielik loetelu koos kasutusdokumentidega on siin.
Vaatame mõnda tööriistade näidet.
DuckDuckGo
DuckDuckGo tööriist võimaldab teil oma otsingumootori abil veebiotsinguid teha. Kasutage seda järgmiselt.
from langchain.tools import DuckDuckGoSearchRun
search = DuckDuckGoSearchRun()
search.run("manchester united vs luton town match summary")
DataForSeo
DataForSeo tööriistakomplekt võimaldab teil hankida otsingumootori tulemusi DataForSeo API abil. Selle tööriistakomplekti kasutamiseks peate seadistama oma API mandaadid. Mandaate konfigureerige järgmiselt.
import os os.environ["DATAFORSEO_LOGIN"] = "<your_api_access_username>"
os.environ["DATAFORSEO_PASSWORD"] = "<your_api_access_password>"
Kui teie mandaadid on määratud, saate luua a DataForSeoAPIWrapper
tööriist API-le juurdepääsuks:
from langchain.utilities.dataforseo_api_search import DataForSeoAPIWrapper wrapper = DataForSeoAPIWrapper() result = wrapper.run("Weather in Los Angeles")
. DataForSeoAPIWrapper
tööriist otsib otsingumootori tulemusi erinevatest allikatest.
Saate kohandada JSON-i vastuses tagastatavate tulemuste ja väljade tüüpi. Näiteks saate määrata tulemuste tüübid, väljad ja määrata tagastatavate parimate tulemuste arvu maksimaalse arvu:
json_wrapper = DataForSeoAPIWrapper( json_result_types=["organic", "knowledge_graph", "answer_box"], json_result_fields=["type", "title", "description", "text"], top_count=3,
) json_result = json_wrapper.results("Bill Gates")
See näide kohandab JSON-vastust, määrates tulemuste tüübid, väljad ja piirates tulemuste arvu.
Samuti saate määrata oma otsingutulemuste asukoha ja keele, edastades API ümbrisele täiendavaid parameetreid.
customized_wrapper = DataForSeoAPIWrapper( top_count=10, json_result_types=["organic", "local_pack"], json_result_fields=["title", "description", "type"], params={"location_name": "Germany", "language_code": "en"},
) customized_result = customized_wrapper.results("coffee near me")
Asukoha- ja keeleparameetrite pakkumisega saate kohandada oma otsingutulemusi konkreetsete piirkondade ja keelte järgi.
Saate paindlikult valida, millist otsingumootorit soovite kasutada. Lihtsalt määrake soovitud otsingumootor:
customized_wrapper = DataForSeoAPIWrapper( top_count=10, json_result_types=["organic", "local_pack"], json_result_fields=["title", "description", "type"], params={"location_name": "Germany", "language_code": "en", "se_name": "bing"},
) customized_result = customized_wrapper.results("coffee near me")
Selles näites on otsing kohandatud kasutama otsingumootorina Bingi.
API ümbris võimaldab teil määrata ka otsingu tüübi, mida soovite teha. Näiteks saate teha kaardiotsingu:
maps_search = DataForSeoAPIWrapper( top_count=10, json_result_fields=["title", "value", "address", "rating", "type"], params={ "location_coordinate": "52.512,13.36,12z", "language_code": "en", "se_type": "maps", },
) maps_search_result = maps_search.results("coffee near me")
See kohandab otsingut kaartidega seotud teabe hankimiseks.
Shell (bash)
Shelli tööriistakomplekt annab agentidele juurdepääsu kestakeskkonnale, võimaldades neil täita shellikäske. See funktsioon on võimas, kuid seda tuleks kasutada ettevaatlikult, eriti liivakastikeskkondades. Shelli tööriista saate kasutada järgmiselt.
from langchain.tools import ShellTool shell_tool = ShellTool() result = shell_tool.run({"commands": ["echo 'Hello World!'", "time"]})
Selles näites käivitab Shelli tööriist kahte shellikäsku: kordades "Tere maailm!" ja praeguse kellaaja kuvamine.
Saate pakkuda agendile Shelli tööriista keerukamate ülesannete täitmiseks. Siin on näide agentist, kes tõmbab Shelli tööriista abil veebilehelt linke.
from langchain.agents import AgentType, initialize_agent
from langchain.chat_models import ChatOpenAI llm = ChatOpenAI(temperature=0.1) shell_tool.description = shell_tool.description + f"args {shell_tool.args}".replace( "{", "{{"
).replace("}", "}}")
self_ask_with_search = initialize_agent( [shell_tool], llm, agent=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION, verbose=True
)
self_ask_with_search.run( "Download the langchain.com webpage and grep for all urls. Return only a sorted list of them. Be sure to use double quotes."
)
Selle stsenaariumi korral kasutab agent Shelli tööriista, et täita käskude jada veebilehe URL-ide toomiseks, filtreerimiseks ja sortimiseks.
Esitatud näited demonstreerivad mõningaid LangChainis saadaolevaid tööriistu. Lõppkokkuvõttes laiendavad need tööriistad agentide võimalusi (seda uuritakse järgmises alajaotises) ja võimaldavad neil erinevaid ülesandeid tõhusalt täita. Sõltuvalt teie nõudmistest saate valida tööriistad ja tööriistakomplektid, mis sobivad kõige paremini teie projekti vajadustega, ning integreerida need oma agendi töövoogudesse.
Tagasi agentide juurde
Liigume nüüd agentide juurde.
AgentExecutor on agendi käituskeskkond. Ta vastutab agendi kutsumise, valitud toimingute täitmise, toiminguväljundite agendile tagasi saatmise ja protsessi kordamise eest, kuni agent on lõpetanud. Pseudokoodis võib AgentExecutor välja näha umbes selline:
next_action = agent.get_action(...)
while next_action != AgentFinish: observation = run(next_action) next_action = agent.get_action(..., next_action, observation)
return next_action
AgentExecutor tegeleb erinevate keerukustega, näiteks selliste juhtumitega, kus agent valib olematu tööriista, tööriistavigade käsitlemine, agendi toodetud väljundite haldamine ning logimise ja jälgitavuse pakkumine kõigil tasanditel.
Kuigi AgentExecutori klass on LangChainis peamine agendi käitusaeg, toetatakse ka teisi, eksperimentaalsemaid käitusaegu, sealhulgas:
- Planeerimise ja teostamise agent
- Beebi AGI
- Automaatne GPT
Agendiraamistiku paremaks mõistmiseks loome põhiagendi nullist ja seejärel jätkame eelnevalt loodud agentide uurimisega.
Enne agendi koostamisse sukeldumist on oluline üle vaadata mõned võtmeterminid ja skeem:
- AgentAction: See on andmeklass, mis esindab toimingut, mida agent peaks tegema. See koosneb a
tool
omadus (väljakutsutava tööriista nimi) ja atool_input
omadus (selle tööriista sisend). - AgentFinish: See andmeklass näitab, et agent on oma ülesande lõpetanud ja peaks kasutajale vastuse tagastama. Tavaliselt sisaldab see tagastusväärtuste sõnastikku, sageli koos vastuseteksti sisaldava võtmega "väljund".
- Vaheetapid: Need on varasemate agendi toimingute ja vastavate väljundite kirjed. Need on olulised konteksti edastamiseks agendi tulevastele iteratsioonidele.
Meie näites kasutame oma agendi loomiseks funktsiooni OpenAI Function Calling. See lähenemisviis on agentide loomisel usaldusväärne. Alustuseks loome lihtsa tööriista, mis arvutab sõna pikkuse. See tööriist on kasulik, kuna keelemudelid võivad mõnikord sõnade pikkuste loendamisel tokeniseerimise tõttu vigu teha.
Kõigepealt laadime keelemudeli, mida kasutame agendi juhtimiseks:
from langchain.chat_models import ChatOpenAI llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
Testime mudelit sõna pikkuse arvutamisega:
llm.invoke("how many letters in the word educa?")
Vastuses tuleks märkida tähtede arv sõnas "educa".
Järgmisena määratleme sõna pikkuse arvutamiseks lihtsa Pythoni funktsiooni:
from langchain.agents import tool @tool
def get_word_length(word: str) -> int: """Returns the length of a word.""" return len(word)
Oleme loonud tööriista nimega get_word_length
mis võtab sisendiks sõna ja tagastab selle pikkuse.
Nüüd loome agendi jaoks viipa. Viip juhendab agenti, kuidas väljundit põhjendada ja vormindada. Meie puhul kasutame OpenAI funktsiooni kutsumist, mis nõuab minimaalseid juhiseid. Määrame viipa kasutaja sisendi kohahoidjatega ja agendi märkmikuga:
from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder prompt = ChatPromptTemplate.from_messages( [ ( "system", "You are a very powerful assistant but not great at calculating word lengths.", ), ("user", "{input}"), MessagesPlaceholder(variable_name="agent_scratchpad"), ]
)
Kuidas agent nüüd teab, milliseid tööriistu ta kasutada saab? Toetume OpenAI funktsioonide kutsumise keelemudelitele, mis nõuavad funktsioonide eraldi edastamist. Oma tööriistade agendile pakkumiseks vormindame need OpenAI funktsioonikutstena:
from langchain.tools.render import format_tool_to_openai_function llm_with_tools = llm.bind(functions=[format_tool_to_openai_function(t) for t in tools])
Nüüd saame agendi luua, määratledes sisendvastused ja ühendades komponendid:
See on LCEL keel. Me arutame seda hiljem üksikasjalikult.
from langchain.agents.format_scratchpad import format_to_openai_function_messages
from langchain.agents.output_parsers import OpenAIFunctionsAgentOutputParser agent = ( { "input": lambda x: x["input"], "agent_scratchpad": lambda x: format_to_openai _function_messages( x["intermediate_steps"] ), } | prompt | llm_with_tools | OpenAIFunctionsAgentOutputParser()
)
Oleme loonud oma agendi, mis mõistab kasutaja sisendit, kasutab saadaolevaid tööriistu ja vormindab väljundit. Nüüd suhtleme sellega:
agent.invoke({"input": "how many letters in the word educa?", "intermediate_steps": []})
Agent peaks vastama AgentActioniga, näidates ära järgmise toimingu.
Oleme agendi loonud, kuid nüüd peame kirjutama sellele käitusaja. Lihtsaim käitusaeg on selline, mis kutsub pidevalt agenti, teostab toiminguid ja kordab, kuni agent lõpetab. Siin on näide:
from langchain.schema.agent import AgentFinish user_input = "how many letters in the word educa?"
intermediate_steps = [] while True: output = agent.invoke( { "input": user_input, "intermediate_steps": intermediate_steps, } ) if isinstance(output, AgentFinish): final_result = output.return_values["output"] break else: print(f"TOOL NAME: {output.tool}") print(f"TOOL INPUT: {output.tool_input}") tool = {"get_word_length": get_word_length}[output.tool] observation = tool.run(output.tool_input) intermediate_steps.append((output, observation)) print(final_result)
Selles tsüklis kutsume korduvalt agendit, teostame toiminguid ja värskendame vaheetappe, kuni agent lõpetab. Samuti käsitleme tsükli sees tööriistade koostoimeid.
Selle protsessi lihtsustamiseks pakub LangChain klassi AgentExecutor, mis sisaldab agendi täitmist ja pakub veakäsitlust, varajast peatamist, jälgimist ja muid täiustusi. Kasutame agendiga suhtlemiseks AgentExecutorit:
from langchain.agents import AgentExecutor agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) agent_executor.invoke({"input": "how many letters in the word educa?"})
AgentExecutor lihtsustab täitmisprotsessi ja pakub mugavat viisi agendiga suhtlemiseks.
Mälust tuleb ka hiljem täpsemalt juttu.
Seni loodud agent on kodakondsuseta, mis tähendab, et see ei mäleta varasemaid suhtlusi. Järelküsimuste ja vestluste lubamiseks peame agendile mälu lisama. See hõlmab kahte sammu:
- Lisage vestlusajaloo salvestamiseks viipale mälumuutuja.
- Jälgige suhtluse ajal vestluste ajalugu.
Alustuseks lisame viipale mälu kohahoidja:
from langchain.prompts import MessagesPlaceholder MEMORY_KEY = "chat_history"
prompt = ChatPromptTemplate.from_messages( [ ( "system", "You are a very powerful assistant but not great at calculating word lengths.", ), MessagesPlaceholder(variable_name=MEMORY_KEY), ("user", "{input}"), MessagesPlaceholder(variable_name="agent_scratchpad"), ]
)
Nüüd looge vestlusajaloo jälgimiseks loend:
from langchain.schema.messages import HumanMessage, AIMessage chat_history = []
Agendi loomise etapis kaasame ka mälu:
agent = ( { "input": lambda x: x["input"], "agent_scratchpad": lambda x: format_to_openai_function_messages( x["intermediate_steps"] ), "chat_history": lambda x: x["chat_history"], } | prompt | llm_with_tools | OpenAIFunctionsAgentOutputParser()
)
Nüüd värskendage agenti käivitades kindlasti vestluste ajalugu:
input1 = "how many letters in the word educa?"
result = agent_executor.invoke({"input": input1, "chat_history": chat_history})
chat_history.extend([ HumanMessage(content=input1), AIMessage(content=result["output"]),
])
agent_executor.invoke({"input": "is that a real word?", "chat_history": chat_history})
See võimaldab agendil säilitada vestluste ajalugu ja vastata eelnevate suhtluste põhjal järelküsimustele.
Palju õnne! Olete edukalt loonud ja käivitanud oma esimese täieliku agendi LangChainis. LangChaini võimalustesse süvenemiseks võite uurida:
- Toetatud erinevad agenditüübid.
- Eelehitatud agendid
- Kuidas töötada tööriistade ja tööriistade integreerimisega.
Agentide tüübid
LangChain pakub erinevaid agentide tüüpe, millest igaüks sobib konkreetseks kasutusjuhtumiks. Siin on mõned saadaolevad agendid:
- Null-shot ReAct: See agent kasutab ReActi raamistikku tööriistade valimiseks ainult nende kirjelduste põhjal. See nõuab iga tööriista kirjeldust ja on väga mitmekülgne.
- Struktureeritud sisend ReAct: See agent käsitleb mitme sisendiga tööriistu ja sobib keeruliste ülesannete jaoks, nagu veebibrauseris navigeerimine. See kasutab struktureeritud sisendiks tööriistade argumentide skeemi.
- OpenAI funktsioonid: Spetsiaalselt funktsioonide kutsumiseks peenhäälestatud mudelite jaoks loodud agent ühildub selliste mudelitega nagu gpt-3.5-turbo-0613 ja gpt-4-0613. Kasutasime seda ülaltoodud esimese agendi loomiseks.
- Vestluslik: Vestlusseadete jaoks loodud agent kasutab tööriista valimiseks ReActi ja varasemate interaktsioonide meelespidamiseks mälu.
- Enda küsimine otsinguga: See agent tugineb ühele tööriistale "Vahepealne vastus", mis otsib küsimustele faktilisi vastuseid. See on samaväärne algse eneseküsimisega otsingupaberiga.
- ReActi dokumendipood: See agent suhtleb dokumendihoidlaga ReActi raamistiku abil. See nõuab otsingu- ja otsingutööriistu ning sarnaneb algse ReActi paberi Wikipedia näitega.
Uurige neid agenditüüpe, et leida LangChainis teie vajadustele kõige paremini sobiv. Need agendid võimaldavad teil tegevuste haldamiseks ja vastuste genereerimiseks nende sees siduda tööriistade komplekti. Lisateavet kuidas siin tööriistade abil oma agenti luua.
Eelehitatud agendid
Jätkame agentide uurimist, keskendudes LangChainis saadaolevatele eelehitatud agentidele.
gmail
LangChain pakub Gmaili tööriistakomplekti, mis võimaldab ühendada oma LangChaini meili Gmaili API-ga. Alustamiseks peate seadistama oma mandaadid, mida on selgitatud Gmaili API dokumentatsioonis. Kui olete alla laadinud credentials.json
faili, võite jätkata Gmaili API kasutamist. Lisaks peate installima mõned nõutavad teegid, kasutades järgmisi käske:
pip install --upgrade google-api-python-client > /dev/null
pip install --upgrade google-auth-oauthlib > /dev/null
pip install --upgrade google-auth-httplib2 > /dev/null
pip install beautifulsoup4 > /dev/null # Optional for parsing HTML messages
Gmaili tööriistakomplekti saate luua järgmiselt.
from langchain.agents.agent_toolkits import GmailToolkit toolkit = GmailToolkit()
Samuti saate autentimist vastavalt oma vajadustele kohandada. Kulisside taga luuakse googleapi ressurss, kasutades järgmisi meetodeid:
from langchain.tools.gmail.utils import build_resource_service, get_gmail_credentials credentials = get_gmail_credentials( token_file="token.json", scopes=["https://mail.google.com/"], client_secrets_file="credentials.json",
)
api_resource = build_resource_service(credentials=credentials)
toolkit = GmailToolkit(api_resource=api_resource)
Tööriistakomplekt pakub mitmesuguseid tööriistu, mida saab agendi sees kasutada, sealhulgas:
GmailCreateDraft
: looge määratud sõnumiväljadega meili mustand.GmailSendMessage
: e-kirjade saatmine.GmailSearch
: otsige meilisõnumeid või lõime.GmailGetMessage
: tooge meilisõnum sõnumi ID järgi.GmailGetThread
: Otsige meilisõnumeid.
Nende tööriistade kasutamiseks agendi sees saate agendi lähtestada järgmiselt.
from langchain.llms import OpenAI
from langchain.agents import initialize_agent, AgentType llm = OpenAI(temperature=0)
agent = initialize_agent( tools=toolkit.get_tools(), llm=llm, agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION,
)
Siin on paar näidet nende tööriistade kasutamise kohta:
- Looge redigeerimiseks Gmaili mustand:
agent.run( "Create a gmail draft for me to edit of a letter from the perspective of a sentient parrot " "who is looking to collaborate on some research with her estranged friend, a cat. " "Under no circumstances may you send the message, however."
)
- Otsige oma mustanditest uusimaid meilisõnumeid:
agent.run("Could you search in my drafts for the latest email?")
Need näited demonstreerivad LangChaini Gmaili tööriistakomplekti võimalusi agendi sees, võimaldades teil Gmailiga programmiliselt suhelda.
SQL andmebaasi agent
See jaotis annab ülevaate agendist, mis on loodud suhtlema SQL-andmebaasidega, eriti Chinooki andmebaasiga. See agent suudab vastata üldistele küsimustele andmebaasi kohta ja taastuda vigadest. Pange tähele, et see on endiselt aktiivses arenduses ja kõik vastused ei pruugi olla õiged. Olge selle tundlikel andmetel käitamisel ettevaatlik, kuna see võib teie andmebaasis esitada DML-lauseid.
Selle agendi kasutamiseks saate selle lähtestada järgmiselt.
from langchain.agents import create_sql_agent
from langchain.agents.agent_toolkits import SQLDatabaseToolkit
from langchain.sql_database import SQLDatabase
from langchain.llms.openai import OpenAI
from langchain.agents import AgentExecutor
from langchain.agents.agent_types import AgentType
from langchain.chat_models import ChatOpenAI db = SQLDatabase.from_uri("sqlite:///../../../../../notebooks/Chinook.db")
toolkit = SQLDatabaseToolkit(db=db, llm=OpenAI(temperature=0)) agent_executor = create_sql_agent( llm=OpenAI(temperature=0), toolkit=toolkit, verbose=True, agent_type=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
)
Seda agenti saab lähtestada kasutades ZERO_SHOT_REACT_DESCRIPTION
agendi tüüp. See on loodud küsimustele vastamiseks ja kirjelduste esitamiseks. Teise võimalusena saate agendi lähtestada, kasutades OPENAI_FUNCTIONS
agendi tüüp OpenAI GPT-3.5-turbo mudeliga, mida kasutasime oma varasemas kliendis.
Kaebused
- Päringuahel võib genereerida sisestamise/värskendamise/kustutamise päringuid. Olge ettevaatlik ja kasutage kohandatud viipa või looge vajadusel SQL-i kasutaja ilma kirjutamisõigusteta.
- Pidage meeles, et teatud päringute (nt "käivita võimalikult suur päring") käivitamine võib teie SQL-andmebaasi üle koormata, eriti kui see sisaldab miljoneid ridu.
- Andmelaole orienteeritud andmebaasid toetavad sageli kasutajataseme kvoote, et piirata ressursside kasutamist.
Võite paluda agendil tabelit kirjeldada, näiteks esitusloendi tabelit. Siin on näide selle kohta, kuidas seda teha.
agent_executor.run("Describe the playlisttrack table")
Agent annab teavet tabeli skeemi ja näidisridade kohta.
Kui küsite ekslikult tabeli kohta, mida pole olemas, saab agent taastada ja anda teavet lähima sobiva tabeli kohta. Näiteks:
agent_executor.run("Describe the playlistsong table")
Agent leiab lähima sobiva tabeli ja annab selle kohta teavet.
Samuti võite paluda agendil andmebaasis päringuid käivitada. Näiteks:
agent_executor.run("List the total sales per country. Which country's customers spent the most?")
Agent täidab päringu ja esitab tulemuse, näiteks riigi, kus on suurim kogumüük.
Iga esitusloendi lugude koguarvu saamiseks võite kasutada järgmist päringut.
agent_executor.run("Show the total number of tracks in each playlist. The Playlist name should be included in the result.")
Agent tagastab esitusloendite nimed koos vastavate lugude koguarvuga.
Juhtudel, kui agent leiab tõrkeid, saab see taastuda ja anda täpseid vastuseid. Näiteks:
agent_executor.run("Who are the top 3 best selling artists?")
Isegi pärast esialgse vea ilmnemist kohandab agent end ja annab õige vastuse, mis on antud juhul 3 enimmüüdud artisti.
Panda DataFrame Agent
Selles jaotises tutvustatakse agenti, mis on loodud Pandas DataFramesiga suhtlemiseks küsimustele vastamise eesmärgil. Pange tähele, et see agent kasutab keelemudeli (LLM) genereeritud Pythoni koodi käivitamiseks kapoti all olevat Pythoni agenti. Olge selle agendi kasutamisel ettevaatlik, et vältida LLM-i genereeritud pahatahtlikust Pythoni koodist tulenevat võimalikku kahju.
Saate Pandas DataFrame'i agendi lähtestada järgmiselt.
from langchain_experimental.agents.agent_toolkits import create_pandas_dataframe_agent
from langchain.chat_models import ChatOpenAI
from langchain.agents.agent_types import AgentType from langchain.llms import OpenAI
import pandas as pd df = pd.read_csv("titanic.csv") # Using ZERO_SHOT_REACT_DESCRIPTION agent type
agent = create_pandas_dataframe_agent(OpenAI(temperature=0), df, verbose=True) # Alternatively, using OPENAI_FUNCTIONS agent type
# agent = create_pandas_dataframe_agent(
# ChatOpenAI(temperature=0, model="gpt-3.5-turbo-0613"),
# df,
# verbose=True,
# agent_type=AgentType.OPENAI_FUNCTIONS,
# )
Saate paluda agendil DataFrame'i ridade arvu kokku lugeda:
agent.run("how many rows are there?")
Agent käivitab koodi df.shape[0]
ja esitage vastus, näiteks "Andmeraamis on 891 rida."
Samuti võite paluda agendil filtreerida ridu konkreetsete kriteeriumide alusel, näiteks leida rohkem kui kolme õe-vennaga inimeste arv.
agent.run("how many people have more than 3 siblings")
Agent käivitab koodi df[df['SibSp'] > 3].shape[0]
ja esitage vastus, näiteks "30 inimesel on rohkem kui kolm õde-venda".
Kui soovite arvutada keskmise vanuse ruutjuure, võite küsida agendilt:
agent.run("whats the square root of the average age?")
Agent arvutab keskmise vanuse, kasutades df['Age'].mean()
ja seejärel arvutage ruutjuur kasutades math.sqrt()
. See annab vastuse, näiteks "Keskmise vanuse ruutjuur on 5.449689683556195."
Loome DataFrame'i koopia ja puuduvad vanuse väärtused täidetakse keskmise vanusega:
df1 = df.copy()
df1["Age"] = df1["Age"].fillna(df1["Age"].mean())
Seejärel saate agendi lähtestada mõlema DataFrame'iga ja esitada sellele küsimuse:
agent = create_pandas_dataframe_agent(OpenAI(temperature=0), [df, df1], verbose=True)
agent.run("how many rows in the age column are different?")
Agent võrdleb mõlema DataFrame'i vanuseveerge ja esitab vastuse, näiteks "177 rida vanuse veerus on erinevad".
Jira tööriistakomplekt
See jaotis selgitab, kuidas kasutada Jira tööriistakomplekti, mis võimaldab agentidel Jira eksemplariga suhelda. Selle tööriistakomplekti abil saate teha mitmesuguseid toiminguid, nagu probleemide otsimine ja probleemide loomine. See kasutab atlassian-python-api raamatukogu. Selle tööriistakomplekti kasutamiseks peate oma Jira eksemplari jaoks määrama keskkonnamuutujad, sealhulgas JIRA_API_TOKEN, JIRA_USERNAME ja JIRA_INSTANCE_URL. Lisaks peate võib-olla määrama oma OpenAI API võtme keskkonnamuutujaks.
Alustamiseks installige atlassian-python-api teek ja määrake vajalikud keskkonnamuutujad:
%pip install atlassian-python-api import os
from langchain.agents import AgentType
from langchain.agents import initialize_agent
from langchain.agents.agent_toolkits.jira.toolkit import JiraToolkit
from langchain.llms import OpenAI
from langchain.utilities.jira import JiraAPIWrapper os.environ["JIRA_API_TOKEN"] = "abc"
os.environ["JIRA_USERNAME"] = "123"
os.environ["JIRA_INSTANCE_URL"] = "https://jira.atlassian.com"
os.environ["OPENAI_API_KEY"] = "xyz" llm = OpenAI(temperature=0)
jira = JiraAPIWrapper()
toolkit = JiraToolkit.from_jira_api_wrapper(jira)
agent = initialize_agent( toolkit.get_tools(), llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True
)
Saate anda agendile käsu luua konkreetses projektis uus probleem koos kokkuvõtte ja kirjeldusega.
agent.run("make a new issue in project PW to remind me to make more fried rice")
Agent teostab probleemi tekitamiseks ja vastuse andmiseks vajalikud toimingud, näiteks "Projektis PW on loodud uus number kokkuvõttega "Tee rohkem praetud riisi" ja kirjeldusega "Meeldetuletus prae riisi valmistamiseks".
See võimaldab teil oma Jira eksemplariga suhelda loomuliku keele juhiste ja Jira tööriistakomplekti abil.
Automatiseerige käsitsi ülesandeid ja töövooge meie AI-põhise töövoo koostajaga, mille on välja töötanud Nanonets teile ja teie meeskondadele.
IV moodul: ketid
LangChain on tööriist, mis on loodud suurte keelemudelite (LLM) kasutamiseks keerulistes rakendustes. See pakub raamistikke komponentide ahelate loomiseks, sealhulgas LLM-id ja muud tüüpi komponendid. Kaks peamist raamistikku
- LangChaini väljenduskeel (LCEL)
- Pärandahela liides
LangChain Expression Language (LCEL) on süntaks, mis võimaldab ahelaid intuitiivselt koostada. See toetab täiustatud funktsioone, nagu voogesitus, asünkroonsed kõned, komplekteerimine, paralleelsus, korduskatsed, varud ja jälgimine. Näiteks saate LCEL-is koostada viipa, mudeli ja väljundparseri, nagu on näidatud järgmises koodis:
from langchain.prompts import ChatPromptTemplate
from langchain.schema import StrOutputParser model = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
prompt = ChatPromptTemplate.from_messages([ ("system", "You're a very knowledgeable historian who provides accurate and eloquent answers to historical questions."), ("human", "{question}")
])
runnable = prompt | model | StrOutputParser() for chunk in runnable.stream({"question": "What are the seven wonders of the world"}): print(chunk, end="", flush=True)
Teise võimalusena on LLMChain komponentide koostamiseks LCEL-iga sarnane valik. LLMChaini näide on järgmine:
from langchain.chains import LLMChain chain = LLMChain(llm=model, prompt=prompt, output_parser=StrOutputParser())
chain.run(question="What are the seven wonders of the world")
LangChaini ahelad võivad olla ka olekupõhised, lisades mäluobjekti. See võimaldab andmete püsivust kõnede vahel, nagu on näidatud järgmises näites:
from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory conversation = ConversationChain(llm=chat, memory=ConversationBufferMemory())
conversation.run("Answer briefly. What are the first 3 colors of a rainbow?")
conversation.run("And the next 4?")
LangChain toetab ka integreerimist OpenAI funktsioonide kutsumise API-dega, mis on kasulik struktureeritud väljundite saamiseks ja funktsioonide täitmiseks ahelas. Struktureeritud väljundite saamiseks saate need määrata Pydantic klasside või JsonSchema abil, nagu allpool näidatud:
from langchain.pydantic_v1 import BaseModel, Field
from langchain.chains.openai_functions import create_structured_output_runnable
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate class Person(BaseModel): name: str = Field(..., description="The person's name") age: int = Field(..., description="The person's age") fav_food: Optional[str] = Field(None, description="The person's favorite food") llm = ChatOpenAI(model="gpt-4", temperature=0)
prompt = ChatPromptTemplate.from_messages([ # Prompt messages here
]) runnable = create_structured_output_runnable(Person, llm, prompt)
runnable.invoke({"input": "Sally is 13"})
Struktureeritud väljundite jaoks on saadaval ka pärandmeetod, mis kasutab LLMChaini:
from langchain.chains.openai_functions import create_structured_output_chain class Person(BaseModel): name: str = Field(..., description="The person's name") age: int = Field(..., description="The person's age") chain = create_structured_output_chain(Person, llm, prompt, verbose=True)
chain.run("Sally is 13")
LangChain kasutab OpenAI funktsioone erinevatel eesmärkidel erinevate spetsiifiliste kettide loomiseks. Nende hulka kuuluvad ekstraheerimise, sildistamise, OpenAPI ja QA ahelad koos tsitaatidega.
Ekstraheerimise kontekstis sarnaneb protsess struktureeritud väljundahelaga, kuid keskendub teabe või olemi kaevandamisele. Märgistamiseks on mõte märgistada dokument selliste klassidega nagu sentiment, keel, stiil, käsitletavad teemad või poliitiline tendents.
Näidet selle kohta, kuidas sildistamine töötab LangChainis, saab näidata Pythoni koodiga. Protsess algab vajalike pakettide installimise ja keskkonna seadistamisega:
pip install langchain openai
# Set env var OPENAI_API_KEY or load from a .env file:
# import dotenv
# dotenv.load_dotenv() from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.chains import create_tagging_chain, create_tagging_chain_pydantic
Määratletakse märgistamise skeem, täpsustades atribuudid ja nende eeldatavad tüübid:
schema = { "properties": { "sentiment": {"type": "string"}, "aggressiveness": {"type": "integer"}, "language": {"type": "string"}, }
} llm = ChatOpenAI(temperature=0, model="gpt-3.5-turbo-0613")
chain = create_tagging_chain(schema, llm)
Erinevate sisenditega märgistamisahela käitamise näited näitavad mudeli võimet tõlgendada tundeid, keeli ja agressiivsust.
inp = "Estoy increiblemente contento de haberte conocido! Creo que seremos muy buenos amigos!"
chain.run(inp)
# {'sentiment': 'positive', 'language': 'Spanish'} inp = "Estoy muy enojado con vos! Te voy a dar tu merecido!"
chain.run(inp)
# {'sentiment': 'enojado', 'aggressiveness': 1, 'language': 'es'}
Täpsemaks juhtimiseks saab skeemi täpsemalt määratleda, kaasa arvatud võimalikud väärtused, kirjeldused ja nõutavad omadused. Selle täiustatud juhtimise näide on näidatud allpool.
schema = { "properties": { # Schema definitions here }, "required": ["language", "sentiment", "aggressiveness"],
} chain = create_tagging_chain(schema, llm)
Pydantilisi skeeme saab kasutada ka märgistamiskriteeriumide määratlemiseks, pakkudes Pythonic'i viisi vajalike omaduste ja tüüpide määramiseks:
from enum import Enum
from pydantic import BaseModel, Field class Tags(BaseModel): # Class fields here chain = create_tagging_chain_pydantic(Tags, llm)
Lisaks saab LangChaini metaandmete sildistaja dokumendimuundurit kasutada metaandmete eraldamiseks LangChaini dokumentidest, pakkudes sildistamisahelaga sarnaseid funktsioone, kuid rakendades seda LangChaini dokumendile.
Otsimisallikate tsiteerimine on veel üks LangChaini funktsioon, mis kasutab tekstist tsitaatide eraldamiseks OpenAI funktsioone. Seda näitab järgmine kood:
from langchain.chains import create_citation_fuzzy_match_chain
from langchain.chat_models import ChatOpenAI llm = ChatOpenAI(temperature=0, model="gpt-3.5-turbo-0613")
chain = create_citation_fuzzy_match_chain(llm)
# Further code for running the chain and displaying results
LangChainis hõlmab suure keelemudeli (LLM) rakendustes aheldamine tavaliselt viipamalli kombineerimist LLM-i ja valikuliselt väljundparseriga. Soovitatav viis seda teha on LangChain Expression Language (LCEL) kaudu, kuigi toetatud on ka pärand LLMChain.
LCEL-i kasutades rakendavad BasePromptTemplate, BaseLanguageModel ja BaseOutputParser Runnable liidest ja neid saab hõlpsasti üksteisega ühendada. Siin on näide, mis seda demonstreerib:
from langchain.prompts import PromptTemplate
from langchain.chat_models import ChatOpenAI
from langchain.schema import StrOutputParser prompt = PromptTemplate.from_template( "What is a good name for a company that makes {product}?"
)
runnable = prompt | ChatOpenAI() | StrOutputParser()
runnable.invoke({"product": "colorful socks"})
# Output: 'VibrantSocks'
Marsruutimine LangChainis võimaldab luua mittedeterministlikke ahelaid, kus eelmise sammu väljund määrab järgmise sammu. See aitab struktureerida ja säilitada järjepidevust suhtluses LLM-idega. Näiteks kui teil on kaks erinevat tüüpi küsimuste jaoks optimeeritud malli, saate malli valida kasutaja sisendi põhjal.
Siin on, kuidas saate seda saavutada, kasutades LCEL-i koos RunnableBranchiga, mis on lähtestatud (tingimus, käivitatavate) paaride loendi ja vaikekäitatava failiga:
from langchain.chat_models import ChatOpenAI
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.runnable import RunnableBranch
# Code for defining physics_prompt and math_prompt general_prompt = PromptTemplate.from_template( "You are a helpful assistant. Answer the question as accurately as you can.nn{input}"
)
prompt_branch = RunnableBranch( (lambda x: x["topic"] == "math", math_prompt), (lambda x: x["topic"] == "physics", physics_prompt), general_prompt,
) # More code for setting up the classifier and final chain
Seejärel koostatakse lõplik ahel, kasutades erinevaid komponente, nagu teemade klassifikaator, viipharu ja väljundparser, et määrata sisendi teemal põhinev voog:
from operator import itemgetter
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.runnable import RunnablePassthrough final_chain = ( RunnablePassthrough.assign(topic=itemgetter("input") | classifier_chain) | prompt_branch | ChatOpenAI() | StrOutputParser()
) final_chain.invoke( { "input": "What is the first prime number greater than 40 such that one plus the prime number is divisible by 3?" }
)
# Output: Detailed answer to the math question
See lähenemine illustreerib LangChaini paindlikkust ja võimsust keeruliste päringute käsitlemisel ja nende õigel suunamisel sisendi põhjal.
Keelemudelite valdkonnas on levinud tava järgida esialgset kõnet järgmiste kõnede seeriaga, kasutades järgmise kõne sisendina ühe kõne väljundit. See järjestikune lähenemine on eriti kasulik, kui soovite tugineda varasemate suhtluste käigus saadud teabele. Kuigi LangChain Expression Language (LCEL) on soovitatav meetod nende jadade loomiseks, on SequentialChain meetod siiski dokumenteeritud selle tagasiühilduvuse jaoks.
Selle illustreerimiseks vaatleme stsenaariumi, kus esmalt genereerime näidendi kokkuvõtte ja seejärel selle konspekti põhjal ülevaate. Pythoni kasutamine langchain.prompts
, loome kaks PromptTemplate
juhtumid: üks kokkuvõtte ja teine ülevaate jaoks. Siin on kood nende mallide seadistamiseks:
from langchain.prompts import PromptTemplate synopsis_prompt = PromptTemplate.from_template( "You are a playwright. Given the title of play, it is your job to write a synopsis for that title.nnTitle: {title}nPlaywright: This is a synopsis for the above play:"
) review_prompt = PromptTemplate.from_template( "You are a play critic from the New York Times. Given the synopsis of play, it is your job to write a review for that play.nnPlay Synopsis:n{synopsis}nReview from a New York Times play critic of the above play:"
)
LCEL-i lähenemisviisi puhul aheldame need viipad ChatOpenAI
ja StrOutputParser
luua jada, mis genereerib esmalt kokkuvõtte ja seejärel ülevaate. Koodilõik on järgmine:
from langchain.chat_models import ChatOpenAI
from langchain.schema import StrOutputParser llm = ChatOpenAI()
chain = ( {"synopsis": synopsis_prompt | llm | StrOutputParser()} | review_prompt | llm | StrOutputParser()
)
chain.invoke({"title": "Tragedy at sunset on the beach"})
Kui vajame nii konspekti kui ka ülevaadet, saame kasutada RunnablePassthrough
et luua igaühe jaoks eraldi ahel ja seejärel need ühendada:
from langchain.schema.runnable import RunnablePassthrough synopsis_chain = synopsis_prompt | llm | StrOutputParser()
review_chain = review_prompt | llm | StrOutputParser()
chain = {"synopsis": synopsis_chain} | RunnablePassthrough.assign(review=review_chain)
chain.invoke({"title": "Tragedy at sunset on the beach"})
Keerulisemaid järjestusi hõlmavate stsenaariumide puhul SequentialChain
meetod tuleb mängu. See võimaldab mitut sisendit ja väljundit. Mõelge juhtumile, kus vajame näidendi pealkirja ja ajastu põhjal kokkuvõtet. Siin on, kuidas saaksime selle seadistada:
from langchain.llms import OpenAI
from langchain.chains import LLMChain, SequentialChain
from langchain.prompts import PromptTemplate llm = OpenAI(temperature=0.7) synopsis_template = "You are a playwright. Given the title of play and the era it is set in, it is your job to write a synopsis for that title.nnTitle: {title}nEra: {era}nPlaywright: This is a synopsis for the above play:"
synopsis_prompt_template = PromptTemplate(input_variables=["title", "era"], template=synopsis_template)
synopsis_chain = LLMChain(llm=llm, prompt=synopsis_prompt_template, output_key="synopsis") review_template = "You are a play critic from the New York Times. Given the synopsis of play, it is your job to write a review for that play.nnPlay Synopsis:n{synopsis}nReview from a New York Times play critic of the above play:"
prompt_template = PromptTemplate(input_variables=["synopsis"], template=review_template)
review_chain = LLMChain(llm=llm, prompt=prompt_template, output_key="review") overall_chain = SequentialChain( chains=[synopsis_chain, review_chain], input_variables=["era", "title"], output_variables=["synopsis", "review"], verbose=True,
) overall_chain({"title": "Tragedy at sunset on the beach", "era": "Victorian England"})
Stsenaariumide korral, kus soovite säilitada konteksti kogu ahelas või ahela hilisemas osas, SimpleMemory
saab kasutada. See on eriti kasulik keerukate sisend/väljundsuhete haldamisel. Näiteks stsenaariumi korral, kus soovime luua sotsiaalmeedia postitusi näidendi pealkirja, ajastu, kokkuvõtte ja arvustuse põhjal, SimpleMemory
võib aidata hallata neid muutujaid:
from langchain.memory import SimpleMemory
from langchain.chains import SequentialChain template = "You are a social media manager for a theater company. Given the title of play, the era it is set in, the date, time and location, the synopsis of the play, and the review of the play, it is your job to write a social media post for that play.nnHere is some context about the time and location of the play:nDate and Time: {time}nLocation: {location}nnPlay Synopsis:n{synopsis}nReview from a New York Times play critic of the above play:n{review}nnSocial Media Post:"
prompt_template = PromptTemplate(input_variables=["synopsis", "review", "time", "location"], template=template)
social_chain = LLMChain(llm=llm, prompt=prompt_template, output_key="social_post_text") overall_chain = SequentialChain( memory=SimpleMemory(memories={"time": "December 25th, 8pm PST", "location": "Theater in the Park"}), chains=[synopsis_chain, review_chain, social_chain], input_variables=["era", "title"], output_variables=["social_post_text"], verbose=True,
) overall_chain({"title": "Tragedy at sunset on the beach", "era": "Victorian England"})
Lisaks järjestikustele ahelatele on dokumentidega töötamiseks spetsiaalsed ahelad. Kõik need ahelad täidavad erinevat eesmärki, alates dokumentide kombineerimisest kuni vastuste täpsustamiseni iteratiivsel dokumendianalüüsil, kuni dokumendi sisu kaardistamise ja vähendamiseni kokkuvõtete tegemiseks või hinnatud vastuste põhjal reastamiseks. Neid kette saab LCEL-iga uuesti luua, et suurendada paindlikkust ja kohandamist.
-
StuffDocumentsChain
ühendab dokumentide loendi üheks viipaks, mis edastatakse LLM-ile. -
RefineDocumentsChain
värskendab oma vastust iteratiivselt iga dokumendi jaoks, mis sobib ülesannete jaoks, kus dokumendid ületavad mudeli kontekstivõimet. -
MapReduceDocumentsChain
rakendab igale dokumendile eraldi ahela ja kombineerib seejärel tulemused. -
MapRerankDocumentsChain
hindab iga dokumendipõhise vastuse ja valib kõrgeima punktisumma.
Siin on näide selle kohta, kuidas saate seadistada a MapReduceDocumentsChain
LCEL-i kasutamine:
from functools import partial
from langchain.chains.combine_documents import collapse_docs, split_list_of_docs
from langchain.schema import Document, StrOutputParser
from langchain.schema.prompt_template import format_document
from langchain.schema.runnable import RunnableParallel, RunnablePassthrough llm = ChatAnthropic()
document_prompt = PromptTemplate.from_template("{page_content}")
partial_format_document = partial(format_document, prompt=document_prompt) map_chain = ( {"context": partial_format_document} | PromptTemplate.from_template("Summarize this content:nn{context}") | llm | StrOutputParser()
) map_as_doc_chain = ( RunnableParallel({"doc": RunnablePassthrough(), "content": map_chain}) | (lambda x: Document(page_content=x["content"], metadata=x["doc"].metadata))
).with_config(run_name="Summarize (return doc)") def format_docs(docs): return "nn".join(partial_format_document(doc) for doc in docs) collapse_chain = ( {"context": format_docs} | PromptTemplate.from_template("Collapse this content:nn{context}") | llm | StrOutputParser()
) reduce_chain = ( {"context": format_docs} | PromptTemplate.from_template("Combine these summaries:nn{context}") | llm | StrOutputParser()
).with_config(run_name="Reduce") map_reduce = (map_as_doc_chain.map() | collapse | reduce_chain).with_config(run_name="Map reduce")
See konfiguratsioon võimaldab dokumentide sisu üksikasjalikku ja kõikehõlmavat analüüsi, kasutades ära LCEL-i ja selle aluseks oleva keelemudeli tugevaid külgi.
Automatiseerige käsitsi ülesandeid ja töövooge meie AI-põhise töövoo koostajaga, mille on välja töötanud Nanonets teile ja teie meeskondadele.
Moodul V: mälu
LangChainis on mälu vestlusliideste põhiaspekt, mis võimaldab süsteemidel viidata varasematele interaktsioonidele. See saavutatakse teabe salvestamise ja päringute tegemisega kahe peamise toiminguga: lugemine ja kirjutamine. Mälusüsteem suhtleb ketiga töötamise ajal kaks korda, suurendades kasutaja sisendeid ning salvestades sisendid ja väljundid edaspidiseks kasutamiseks.
Mälu loomine süsteemiks
- Vestlussõnumite salvestamine: LangChaini mälumoodul integreerib vestlussõnumite salvestamiseks erinevaid meetodeid, alates mälusisestest loenditest kuni andmebaasideni. See tagab, et kõik vestluse interaktsioonid salvestatakse edaspidiseks kasutamiseks.
- Vestlussõnumite päring: Lisaks vestlussõnumite salvestamisele kasutab LangChain andmestruktuure ja algoritme, et luua neist sõnumitest kasulik vaade. Lihtsad mälusüsteemid võivad tagastada hiljutisi sõnumeid, samas kui arenenumad süsteemid võivad teha kokkuvõtte varasematest interaktsioonidest või keskenduda praeguses suhtluses mainitud üksustele.
LangChainis mälu kasutamise demonstreerimiseks kaaluge ConversationBufferMemory
klass, lihtne mäluvorm, mis salvestab vestlussõnumid puhvrisse. Siin on näide:
from langchain.memory import ConversationBufferMemory memory = ConversationBufferMemory()
memory.chat_memory.add_user_message("Hello!")
memory.chat_memory.add_ai_message("How can I assist you?")
Mälu ahelasse integreerimisel on ülioluline mõista mälust tagastatud muutujaid ja seda, kuidas neid ahelas kasutatakse. Näiteks load_memory_variables
meetod aitab viia mälust loetud muutujad vastavusse ahela ootustega.
Otsast lõpuni näide LangChainiga
Kaaluge kasutamist ConversationBufferMemory
aastal LLMChain
. Kett koos sobiva viipamalli ja mäluga tagab sujuva vestluskogemuse. Siin on lihtsustatud näide:
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
from langchain.memory import ConversationBufferMemory llm = OpenAI(temperature=0)
template = "Your conversation template here..."
prompt = PromptTemplate.from_template(template)
memory = ConversationBufferMemory(memory_key="chat_history")
conversation = LLMChain(llm=llm, prompt=prompt, memory=memory) response = conversation({"question": "What's the weather like?"})
See näide illustreerib, kuidas LangChaini mälusüsteem integreerub oma kettidega, et pakkuda ühtset ja kontekstitundlikku vestluskogemust.
Mälutüübid Langchainis
Langchain pakub erinevaid mälutüüpe, mida saab kasutada tehisintellekti mudelitega suhtlemise tõhustamiseks. Igal mälutüübil on oma parameetrid ja tagastustüübid, mistõttu need sobivad erinevate stsenaariumide jaoks. Uurime mõnda Langchainis saadaolevat mälutüüpi koos koodinäidetega.
1. Vestluspuhvri mälu
See mälutüüp võimaldab teil vestlustest sõnumeid salvestada ja neist eraldada. Ajaloo saate eraldada stringina või sõnumite loendina.
from langchain.memory import ConversationBufferMemory memory = ConversationBufferMemory()
memory.save_context({"input": "hi"}, {"output": "whats up"})
memory.load_memory_variables({}) # Extract history as a string
{'history': 'Human: hinAI: whats up'} # Extract history as a list of messages
{'history': [HumanMessage(content='hi', additional_kwargs={}), AIMessage(content='whats up', additional_kwargs={})]}
Vestluspuhvri mälu saate kasutada ka ahelas vestlustaoliseks suhtluseks.
2. Vestluspuhvri akna mälu
See mälutüüp hoiab viimaste interaktsioonide loendit ja kasutab viimast K interaktsiooni, vältides puhvri liiga suureks muutumist.
from langchain.memory import ConversationBufferWindowMemory memory = ConversationBufferWindowMemory(k=1)
memory.save_context({"input": "hi"}, {"output": "whats up"})
memory.save_context({"input": "not much you"}, {"output": "not much"})
memory.load_memory_variables({}) {'history': 'Human: not much younAI: not much'}
Sarnaselt vestluspuhvri mäluga saate seda mälutüüpi kasutada ka ahelas vestlustaoliste suhtluste jaoks.
3. Vestlusolemi mälu
See mälutüüp jätab meelde faktid konkreetsete üksuste kohta vestluses ja eraldab teavet LLM-i abil.
from langchain.memory import ConversationEntityMemory
from langchain.llms import OpenAI llm = OpenAI(temperature=0)
memory = ConversationEntityMemory(llm=llm)
_input = {"input": "Deven & Sam are working on a hackathon project"}
memory.load_memory_variables(_input)
memory.save_context( _input, {"output": " That sounds like a great project! What kind of project are they working on?"}
)
memory.load_memory_variables({"input": 'who is Sam'}) {'history': 'Human: Deven & Sam are working on a hackathon projectnAI: That sounds like a great project! What kind of project are they working on?', 'entities': {'Sam': 'Sam is working on a hackathon project with Deven.'}}
4. Vestluste teadmiste graafiku mälu
See mälutüüp kasutab mälu taasloomiseks teadmiste graafikut. Saate sõnumitest eraldada praegused olemid ja teadmiste kolmikud.
from langchain.memory import ConversationKGMemory
from langchain.llms import OpenAI llm = OpenAI(temperature=0)
memory = ConversationKGMemory(llm=llm)
memory.save_context({"input": "say hi to sam"}, {"output": "who is sam"})
memory.save_context({"input": "sam is a friend"}, {"output": "okay"})
memory.load_memory_variables({"input": "who is sam"}) {'history': 'On Sam: Sam is friend.'}
Seda mälutüüpi saate kasutada ka ahelas vestluspõhiseks teadmiste otsimiseks.
5. Vestluse kokkuvõtte mälu
See mälutüüp loob vestlusest aja jooksul kokkuvõtte, mis on kasulik pikemate vestluste teabe koondamiseks.
from langchain.memory import ConversationSummaryMemory
from langchain.llms import OpenAI llm = OpenAI(temperature=0)
memory = ConversationSummaryMemory(llm=llm)
memory.save_context({"input": "hi"}, {"output": "whats up"})
memory.load_memory_variables({}) {'history': 'nThe human greets the AI, to which the AI responds.'}
6. Vestluse kokkuvõtte puhvermälu
See mälutüüp ühendab vestluse kokkuvõtte ja puhvri, säilitades tasakaalu hiljutiste interaktsioonide ja kokkuvõtte vahel. See kasutab märgi pikkust, et määrata, millal interaktsioone loputada.
from langchain.memory import ConversationSummaryBufferMemory
from langchain.llms import OpenAI llm = OpenAI()
memory = ConversationSummaryBufferMemory(llm=llm, max_token_limit=10)
memory.save_context({"input": "hi"}, {"output": "whats up"})
memory.save_context({"input": "not much you"}, {"output": "not much"})
memory.load_memory_variables({}) {'history': 'System: nThe human says "hi", and the AI responds with "whats up".nHuman: not much younAI: not much'}
Saate kasutada neid mälutüüpe, et täiustada oma suhtlust AI mudelitega Langchainis. Iga mälutüüp teenib kindlat eesmärki ja seda saab valida vastavalt teie vajadustele.
7. Vestluslubade puhvermälu
ConversationTokenBufferMemory on veel üks mälutüüp, mis hoiab mälus viimaste interaktsioonide puhvrit. Erinevalt eelmistest mälutüüpidest, mis keskenduvad interaktsioonide arvule, kasutab see interaktsioonide kustutamise aja määramiseks märgi pikkust.
Mälu kasutamine koos LLM-iga:
from langchain.memory import ConversationTokenBufferMemory
from langchain.llms import OpenAI llm = OpenAI() memory = ConversationTokenBufferMemory(llm=llm, max_token_limit=10)
memory.save_context({"input": "hi"}, {"output": "whats up"})
memory.save_context({"input": "not much you"}, {"output": "not much"}) memory.load_memory_variables({}) {'history': 'Human: not much younAI: not much'}
Selles näites on mälu seatud interaktsioone piirama pigem märgi pikkuse kui interaktsioonide arvu alusel.
Seda mälutüüpi kasutades saate ajaloo ka sõnumite loendina.
memory = ConversationTokenBufferMemory( llm=llm, max_token_limit=10, return_messages=True
)
memory.save_context({"input": "hi"}, {"output": "whats up"})
memory.save_context({"input": "not much you"}, {"output": "not much"})
Kasutamine ahelas:
Saate kasutada ahelas ConversationTokenBufferMemory, et tõhustada interaktsiooni AI mudeliga.
from langchain.chains import ConversationChain conversation_with_summary = ConversationChain( llm=llm, # We set a very low max_token_limit for the purposes of testing. memory=ConversationTokenBufferMemory(llm=OpenAI(), max_token_limit=60), verbose=True,
)
conversation_with_summary.predict(input="Hi, what's up?")
Selles näites kasutatakse ConversationTokenBufferMemory'i vestlusahelas vestluse haldamiseks ja interaktsioonide piiramiseks loa pikkuse alusel.
8. VectorStoreRetrieverMemory
VectorStoreRetrieverMemory salvestab mälestused vektormällu ja küsib iga kord, kui seda kutsutakse, K kõige olulisematest dokumentidest. See mälutüüp ei jälgi selgesõnaliselt interaktsioonide järjekorda, vaid kasutab asjakohaste mälestuste toomiseks vektorotsingut.
from datetime import datetime
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.llms import OpenAI
from langchain.memory import VectorStoreRetrieverMemory
from langchain.chains import ConversationChain
from langchain.prompts import PromptTemplate # Initialize your vector store (specifics depend on the chosen vector store)
import faiss
from langchain.docstore import InMemoryDocstore
from langchain.vectorstores import FAISS embedding_size = 1536 # Dimensions of the OpenAIEmbeddings
index = faiss.IndexFlatL2(embedding_size)
embedding_fn = OpenAIEmbeddings().embed_query
vectorstore = FAISS(embedding_fn, index, InMemoryDocstore({}), {}) # Create your VectorStoreRetrieverMemory
retriever = vectorstore.as_retriever(search_kwargs=dict(k=1))
memory = VectorStoreRetrieverMemory(retriever=retriever) # Save context and relevant information to the memory
memory.save_context({"input": "My favorite food is pizza"}, {"output": "that's good to know"})
memory.save_context({"input": "My favorite sport is soccer"}, {"output": "..."})
memory.save_context({"input": "I don't like the Celtics"}, {"output": "ok"}) # Retrieve relevant information from memory based on a query
print(memory.load_memory_variables({"prompt": "what sport should i watch?"})["history"])
Selles näites kasutatakse VectorStoreRetrieverMemory vestlusest asjakohase teabe salvestamiseks ja toomiseks vektorotsingu alusel.
Vestlusepõhiseks teadmiste otsimiseks saate ahelas kasutada ka VectorStoreRetrieverMemory, nagu on näidatud eelmistes näidetes.
Need Langchaini erinevad mälutüübid pakuvad erinevaid viise vestlustest teabe haldamiseks ja hankimiseks, suurendades tehisintellekti mudelite võimalusi kasutajate päringute ja konteksti mõistmisel ja neile vastamisel. Iga mälutüübi saab valida teie rakenduse spetsiifiliste nõuete alusel.
Nüüd õpime, kuidas kasutada mälu LLMChainiga. Mälu LLMChainis võimaldab mudelil meeles pidada varasemaid interaktsioone ja konteksti, et pakkuda sidusamaid ja kontekstiteadlikumaid vastuseid.
Mälu seadistamiseks LLMChainis peate looma mäluklassi, näiteks ConversationBufferMemory. Saate selle seadistada järgmiselt.
from langchain.chains import LLMChain
from langchain.llms import OpenAI
from langchain.memory import ConversationBufferMemory
from langchain.prompts import PromptTemplate template = """You are a chatbot having a conversation with a human. {chat_history}
Human: {human_input}
Chatbot:""" prompt = PromptTemplate( input_variables=["chat_history", "human_input"], template=template
)
memory = ConversationBufferMemory(memory_key="chat_history") llm = OpenAI()
llm_chain = LLMChain( llm=llm, prompt=prompt, verbose=True, memory=memory,
) llm_chain.predict(human_input="Hi there my friend")
Selles näites kasutatakse vestluste ajaloo salvestamiseks ConversationBufferMemory. The memory_key
parameeter määrab võtme, mida kasutatakse vestluste ajaloo salvestamiseks.
Kui kasutate lõpetamisstiilis mudeli asemel vestlusmudelit, saate mälu paremaks kasutamiseks struktureerida viipasid erinevalt. Siin on näide, kuidas seadistada vestlusmudelil põhinev mäluga LLMChain:
from langchain.chat_models import ChatOpenAI
from langchain.schema import SystemMessage
from langchain.prompts import ( ChatPromptTemplate, HumanMessagePromptTemplate, MessagesPlaceholder,
) # Create a ChatPromptTemplate
prompt = ChatPromptTemplate.from_messages( [ SystemMessage( content="You are a chatbot having a conversation with a human." ), # The persistent system prompt MessagesPlaceholder( variable_name="chat_history" ), # Where the memory will be stored. HumanMessagePromptTemplate.from_template( "{human_input}" ), # Where the human input will be injected ]
) memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True) llm = ChatOpenAI() chat_llm_chain = LLMChain( llm=llm, prompt=prompt, verbose=True, memory=memory,
) chat_llm_chain.predict(human_input="Hi there my friend")
Selles näites kasutatakse viipa struktureerimiseks ChatPromptTemplate ja vestluse ajaloo salvestamiseks ja toomiseks ConversationBufferMemory. See lähenemine on eriti kasulik vestluse stiilis vestluste puhul, kus kontekst ja ajalugu mängivad otsustavat rolli.
Mälu saab lisada ka mitme sisendiga ahelasse, näiteks küsimuste/vastuste ahel. Siin on näide küsimuste/vastuste ahelas mälu seadistamise kohta:
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.embeddings.cohere import CohereEmbeddings
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores.elastic_vector_search import ElasticVectorSearch
from langchain.vectorstores import Chroma
from langchain.docstore.document import Document
from langchain.chains.question_answering import load_qa_chain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.memory import ConversationBufferMemory # Split a long document into smaller chunks
with open("../../state_of_the_union.txt") as f: state_of_the_union = f.read()
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_text(state_of_the_union) # Create an ElasticVectorSearch instance to index and search the document chunks
embeddings = OpenAIEmbeddings()
docsearch = Chroma.from_texts( texts, embeddings, metadatas=[{"source": i} for i in range(len(texts))]
) # Perform a question about the document
query = "What did the president say about Justice Breyer"
docs = docsearch.similarity_search(query) # Set up a prompt for the question-answering chain with memory
template = """You are a chatbot having a conversation with a human. Given the following extracted parts of a long document and a question, create a final answer. {context} {chat_history}
Human: {human_input}
Chatbot:""" prompt = PromptTemplate( input_variables=["chat_history", "human_input", "context"], template=template
)
memory = ConversationBufferMemory(memory_key="chat_history", input_key="human_input")
chain = load_qa_chain( OpenAI(temperature=0), chain_type="stuff", memory=memory, prompt=prompt
) # Ask the question and retrieve the answer
query = "What did the president say about Justice Breyer"
result = chain({"input_documents": docs, "human_input": query}, return_only_outputs=True) print(result)
print(chain.memory.buffer)
Selles näites vastatakse küsimusele, kasutades dokumenti, mis on jagatud väiksemateks tükkideks. ConversationBufferMemory kasutatakse vestluste ajaloo salvestamiseks ja toomiseks, võimaldades mudelil pakkuda kontekstiteadlikke vastuseid.
Agendile mälu lisamine võimaldab tal meeles pidada ja kasutada varasemaid interaktsioone küsimustele vastamiseks ja kontekstiteadlike vastuste andmiseks. Saate agendis mälu seadistada järgmiselt.
from langchain.agents import ZeroShotAgent, Tool, AgentExecutor
from langchain.memory import ConversationBufferMemory
from langchain.llms import OpenAI
from langchain.chains import LLMChain
from langchain.utilities import GoogleSearchAPIWrapper # Create a tool for searching
search = GoogleSearchAPIWrapper()
tools = [ Tool( name="Search", func=search.run, description="useful for when you need to answer questions about current events", )
] # Create a prompt with memory
prefix = """Have a conversation with a human, answering the following questions as best you can. You have access to the following tools:"""
suffix = """Begin!" {chat_history}
Question: {input}
{agent_scratchpad}""" prompt = ZeroShotAgent.create_prompt( tools, prefix=prefix, suffix=suffix, input_variables=["input", "chat_history", "agent_scratchpad"],
)
memory = ConversationBufferMemory(memory_key="chat_history") # Create an LLMChain with memory
llm_chain = LLMChain(llm=OpenAI(temperature=0), prompt=prompt)
agent = ZeroShotAgent(llm_chain=llm_chain, tools=tools, verbose=True)
agent_chain = AgentExecutor.from_agent_and_tools( agent=agent, tools=tools, verbose=True, memory=memory
) # Ask a question and retrieve the answer
response = agent_chain.run(input="How many people live in Canada?")
print(response) # Ask a follow-up question
response = agent_chain.run(input="What is their national anthem called?")
print(response)
Selles näites lisatakse agendile mälu, mis võimaldab tal meeles pidada eelmist vestluste ajalugu ja pakkuda kontekstiteadlikke vastuseid. See võimaldab agendil mällu salvestatud teabe põhjal järelküsimustele täpselt vastata.
LangChaini väljenduskeel
Loomuliku keele töötlemise ja masinõppe maailmas võib keerukate toimingute ahelate koostamine olla hirmutav ülesanne. Õnneks tuleb appi LangChain Expression Language (LCEL), mis pakub deklaratiivset ja tõhusat viisi keerukate keeletöötluse torustike ehitamiseks ja juurutamiseks. LCEL on loodud ahelate koostamise protsessi lihtsustamiseks, võimaldades prototüüpide loomisest tootmiseni hõlpsalt üle minna. Selles ajaveebis uurime, mis on LCEL ja miks võiksite seda kasutada, koos praktiliste koodinäidetega selle võimaluste illustreerimiseks.
LCEL ehk LangChain Expression Language on võimas tööriist keeletöötlusahelate koostamiseks. See oli loodud selleks, et toetada sujuvalt üleminekut prototüüpimiselt tootmisele ilma ulatuslikke koodimuutusi nõudmata. Olenemata sellest, kas ehitate lihtsat "prompt + LLM" ahelat või keerukat sadade sammudega torujuhet, LCEL pakub teile lahendust.
Siin on mõned põhjused, miks kasutada keeletöötlusprojektides LCEL-i:
- Tokenite kiire voogesitus: LCEL edastab märgid keelemudelist väljundparserisse reaalajas, parandades reageerimisvõimet ja tõhusust.
- Mitmekülgsed API-d: LCEL toetab nii sünkroonseid kui ka asünkroonseid API-sid prototüüpide loomiseks ja tootmiseks, käsitledes tõhusalt mitut päringut.
- Automaatne paralleelsus: LCEL optimeerib võimalusel paralleelkäivitust, vähendades latentsust nii sünkroonimis- kui ka asünkroonimisliidestes.
- Usaldusväärsed konfiguratsioonid: konfigureerige korduskatseid ja varundusi, et suurendada ahela mastaabis usaldusväärsust koos arenduses oleva voogesituse toega.
- Vahetulemuste voogesitus: juurdepääsu vahetulemustele töötlemise ajal kasutajate värskenduste või silumise eesmärgil.
- Skeemi genereerimine: LCEL genereerib sisendi ja väljundi valideerimiseks Pydantic ja JSONSchema skeeme.
- Põhjalik jälgimine: LangSmith jälgib jälgitavuse ja silumise tagamiseks automaatselt kõiki etappe keerulistes ahelates.
- Lihtne juurutamine: juurutage LCEL-i loodud kette hõlpsalt LangServe'i abil.
Nüüd sukeldume praktilistesse koodinäidetesse, mis demonstreerivad LCEL-i võimsust. Uurime levinumaid ülesandeid ja stsenaariume, kus LCEL paistab silma.
Viip + LLM
Kõige põhilisem kompositsioon hõlmab viipa ja keelemudeli kombineerimist, et luua kett, mis võtab kasutaja sisendi, lisab selle viipale, edastab selle mudelile ja tagastab mudeli töötlemata väljundi. Siin on näide:
from langchain.prompts import ChatPromptTemplate
from langchain.chat_models import ChatOpenAI prompt = ChatPromptTemplate.from_template("tell me a joke about {foo}")
model = ChatOpenAI()
chain = prompt | model result = chain.invoke({"foo": "bears"})
print(result)
Selles näites genereerib kett karude kohta nalja.
Saate oma ahelale lisada stoppjärjestused, et juhtida, kuidas see teksti töötleb. Näiteks:
chain = prompt | model.bind(stop=["n"])
result = chain.invoke({"foo": "bears"})
print(result)
See konfiguratsioon peatab teksti genereerimise, kui tekib reavahetus.
LCEL toetab funktsioonikõne teabe lisamist teie ahelale. Siin on näide:
functions = [ { "name": "joke", "description": "A joke", "parameters": { "type": "object", "properties": { "setup": {"type": "string", "description": "The setup for the joke"}, "punchline": { "type": "string", "description": "The punchline for the joke", }, }, "required": ["setup", "punchline"], }, }
]
chain = prompt | model.bind(function_call={"name": "joke"}, functions=functions)
result = chain.invoke({"foo": "bears"}, config={})
print(result)
See näide lisab nalja loomiseks funktsiooni kutsumisteabe.
Viip + LLM + OutputParser
Saate lisada väljundparseri, et muuta toormudeli väljund paremini toimivaks vorminguks. Seda saate teha järgmiselt.
from langchain.schema.output_parser import StrOutputParser chain = prompt | model | StrOutputParser()
result = chain.invoke({"foo": "bears"})
print(result)
Väljund on nüüd stringvormingus, mis on allavoolu ülesannete jaoks mugavam.
Tagastatava funktsiooni määramisel saate selle otse LCEL-i abil sõeluda. Näiteks:
from langchain.output_parsers.openai_functions import JsonOutputFunctionsParser chain = ( prompt | model.bind(function_call={"name": "joke"}, functions=functions) | JsonOutputFunctionsParser()
)
result = chain.invoke({"foo": "bears"})
print(result)
See näide analüüsib otse funktsiooni "nali" väljundit.
Need on vaid mõned näited sellest, kuidas LCEL lihtsustab keerulisi keeletöötlusülesandeid. Ükskõik, kas loote vestlusroboteid, loote sisu või teostate keerukaid tekstiteisendusi, LCEL saab teie töövoogu sujuvamaks muuta ja koodi hooldatavamaks muuta.
RAG (Retrieval-augmented Generation)
LCEL-i saab kasutada otsimisega laiendatud genereerimisahelate loomiseks, mis ühendavad otsingu ja keele genereerimise etapid. Siin on näide:
from operator import itemgetter from langchain.prompts import ChatPromptTemplate
from langchain.chat_models import ChatOpenAI
from langchain.embeddings import OpenAIEmbeddings
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.runnable import RunnablePassthrough, RunnableLambda
from langchain.vectorstores import FAISS # Create a vector store and retriever
vectorstore = FAISS.from_texts( ["harrison worked at kensho"], embedding=OpenAIEmbeddings()
)
retriever = vectorstore.as_retriever() # Define templates for prompts
template = """Answer the question based only on the following context:
{context} Question: {question} """
prompt = ChatPromptTemplate.from_template(template) model = ChatOpenAI() # Create a retrieval-augmented generation chain
chain = ( {"context": retriever, "question": RunnablePassthrough()} | prompt | model | StrOutputParser()
) result = chain.invoke("where did harrison work?")
print(result)
Selles näites hangib kett kontekstist asjakohase teabe ja genereerib küsimusele vastuse.
Vestlusahel
Saate hõlpsasti vestluste ajalugu oma kettidele lisada. Siin on näide vestluse otsinguahelast:
from langchain.schema.runnable import RunnableMap
from langchain.schema import format_document from langchain.prompts.prompt import PromptTemplate # Define templates for prompts
_template = """Given the following conversation and a follow up question, rephrase the follow up question to be a standalone question, in its original language. Chat History:
{chat_history}
Follow Up Input: {question}
Standalone question:"""
CONDENSE_QUESTION_PROMPT = PromptTemplate.from_template(_template) template = """Answer the question based only on the following context:
{context} Question: {question} """
ANSWER_PROMPT = ChatPromptTemplate.from_template(template) # Define input map and context
_inputs = RunnableMap( standalone_question=RunnablePassthrough.assign( chat_history=lambda x: _format_chat_history(x["chat_history"]) ) | CONDENSE_QUESTION_PROMPT | ChatOpenAI(temperature=0) | StrOutputParser(),
)
_context = { "context": itemgetter("standalone_question") | retriever | _combine_documents, "question": lambda x: x["standalone_question"],
}
conversational_qa_chain = _inputs | _context | ANSWER_PROMPT | ChatOpenAI() result = conversational_qa_chain.invoke( { "question": "where did harrison work?", "chat_history": [], }
)
print(result)
Selles näites käsitleb kett vestluse kontekstis järelküsimust.
Mälu ja lähtedokumentidega
LCEL toetab ka mälu ja lähtedokumentide tagastamist. Saate ahelas mälu kasutada järgmiselt.
from operator import itemgetter
from langchain.memory import ConversationBufferMemory # Create a memory instance
memory = ConversationBufferMemory( return_messages=True, output_key="answer", input_key="question"
) # Define steps for the chain
loaded_memory = RunnablePassthrough.assign( chat_history=RunnableLambda(memory.load_memory_variables) | itemgetter("history"),
) standalone_question = { "standalone_question": { "question": lambda x: x["question"], "chat_history": lambda x: _format_chat_history(x["chat_history"]), } | CONDENSE_QUESTION_PROMPT | ChatOpenAI(temperature=0) | StrOutputParser(),
} retrieved_documents = { "docs": itemgetter("standalone_question") | retriever, "question": lambda x: x["standalone_question"],
} final_inputs = { "context": lambda x: _combine_documents(x["docs"]), "question": itemgetter("question"),
} answer = { "answer": final_inputs | ANSWER_PROMPT | ChatOpenAI(), "docs": itemgetter("docs"),
} # Create the final chain by combining the steps
final_chain = loaded_memory | standalone_question | retrieved_documents | answer inputs = {"question": "where did harrison work?"}
result = final_chain.invoke(inputs)
print(result)
Selles näites kasutatakse mälu vestluste ajaloo ja lähtedokumentide salvestamiseks ja toomiseks.
Mitu ketti
Runnablesi abil saate mitu ahelat kokku panna. Siin on näide:
from operator import itemgetter from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema import StrOutputParser prompt1 = ChatPromptTemplate.from_template("what is the city {person} is from?")
prompt2 = ChatPromptTemplate.from_template( "what country is the city {city} in? respond in {language}"
) model = ChatOpenAI() chain1 = prompt1 | model | StrOutputParser() chain2 = ( {"city": chain1, "language": itemgetter("language")} | prompt2 | model | StrOutputParser()
) result = chain2.invoke({"person": "obama", "language": "spanish"})
print(result)
Selles näites ühendatakse kaks ahelat, et luua teavet linna ja selle riigi kohta kindlas keeles.
Hargnemine ja ühinemine
LCEL võimaldab teil RunnableMapsi abil kette jagada ja liita. Siin on näide hargnemisest ja ühendamisest:
from operator import itemgetter from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema import StrOutputParser planner = ( ChatPromptTemplate.from_template("Generate an argument about: {input}") | ChatOpenAI() | StrOutputParser() | {"base_response": RunnablePassthrough()}
) arguments_for = ( ChatPromptTemplate.from_template( "List the pros or positive aspects of {base_response}" ) | ChatOpenAI() | StrOutputParser()
)
arguments_against = ( ChatPromptTemplate.from_template( "List the cons or negative aspects of {base_response}" ) | ChatOpenAI() | StrOutputParser()
) final_responder = ( ChatPromptTemplate.from_messages( [ ("ai", "{original_response}"), ("human", "Pros:n{results_1}nnCons:n{results_2}"), ("system", "Generate a final response given the critique"), ] ) | ChatOpenAI() | StrOutputParser()
) chain = ( planner | { "results_1": arguments_for, "results_2": arguments_against, "original_response": itemgetter("base_response"), } | final_responder
) result = chain.invoke({"input": "scrum"})
print(result)
Selles näites kasutatakse hargnevat ja ühendavat ahelat argumendi genereerimiseks ning selle plusside ja miinuste hindamiseks enne lõpliku vastuse genereerimist.
Pythoni koodi kirjutamine LCEL-iga
LangChain Expression Language (LCEL) üks võimsamaid rakendusi on Pythoni koodi kirjutamine kasutajaprobleemide lahendamiseks. Allpool on näide LCEL-i kasutamisest Pythoni koodi kirjutamiseks:
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser
from langchain_experimental.utilities import PythonREPL template = """Write some python code to solve the user's problem. Return only python code in Markdown format, e.g.: ```python
....
```"""
prompt = ChatPromptTemplate.from_messages([("system", template), ("human", "{input}")]) model = ChatOpenAI() def _sanitize_output(text: str): _, after = text.split("```python") return after.split("```")[0] chain = prompt | model | StrOutputParser() | _sanitize_output | PythonREPL().run result = chain.invoke({"input": "what's 2 plus 2"})
print(result)
Selles näites annab kasutaja sisendi ja LCEL genereerib probleemi lahendamiseks Pythoni koodi. Seejärel käivitatakse kood Pythoni REPL-i abil ja saadud Pythoni kood tagastatakse Markdowni vormingus.
Pange tähele, et Pythoni REPL-i kasutamine võib käivitada suvalise koodi, seega kasutage seda ettevaatlikult.
Mälu lisamine ahelasse
Mälu on paljudes vestluspõhises AI rakendustes hädavajalik. Suvalisele ahelale mälu lisamiseks tehke järgmist.
from operator import itemgetter
from langchain.chat_models import ChatOpenAI
from langchain.memory import ConversationBufferMemory
from langchain.schema.runnable import RunnablePassthrough, RunnableLambda
from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder model = ChatOpenAI()
prompt = ChatPromptTemplate.from_messages( [ ("system", "You are a helpful chatbot"), MessagesPlaceholder(variable_name="history"), ("human", "{input}"), ]
) memory = ConversationBufferMemory(return_messages=True) # Initialize memory
memory.load_memory_variables({}) chain = ( RunnablePassthrough.assign( history=RunnableLambda(memory.load_memory_variables) | itemgetter("history") ) | prompt | model
) inputs = {"input": "hi, I'm Bob"}
response = chain.invoke(inputs)
response # Save the conversation in memory
memory.save_context(inputs, {"output": response.content}) # Load memory to see the conversation history
memory.load_memory_variables({})
Selles näites kasutatakse mälu vestluste ajaloo salvestamiseks ja toomiseks, mis võimaldab vestlusrotil säilitada konteksti ja reageerida asjakohaselt.
Väliste tööriistade kasutamine Runnables'iga
LCEL võimaldab teil väliseid tööriistu Runnables-iga sujuvalt integreerida. Siin on näide DuckDuckGo otsingutööriista kasutamisest:
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser
from langchain.tools import DuckDuckGoSearchRun search = DuckDuckGoSearchRun() template = """Turn the following user input into a search query for a search engine: {input}"""
prompt = ChatPromptTemplate.from_template(template) model = ChatOpenAI() chain = prompt | model | StrOutputParser() | search search_result = chain.invoke({"input": "I'd like to figure out what games are tonight"})
print(search_result)
Selles näites integreerib LCEL ahelasse DuckDuckGo Search tööriista, võimaldades tal genereerida kasutaja sisendi põhjal otsingupäringut ja tuua otsingutulemusi.
LCEL-i paindlikkus muudab erinevate väliste tööriistade ja teenuste lisamise keeletöötluskonveieritesse lihtsaks, suurendades nende võimalusi ja funktsionaalsust.
Modereerimise lisamine LLM-i rakendusele
Tagamaks, et teie LLM-rakendus järgib sisupoliitikat ja sisaldab modereerimiskaitsemeetmeid, saate modereerimiskontrollid oma ketti integreerida. LangChaini abil modereerimise lisamiseks tehke järgmist.
from langchain.chains import OpenAIModerationChain
from langchain.llms import OpenAI
from langchain.prompts import ChatPromptTemplate moderate = OpenAIModerationChain() model = OpenAI()
prompt = ChatPromptTemplate.from_messages([("system", "repeat after me: {input}")]) chain = prompt | model # Original response without moderation
response_without_moderation = chain.invoke({"input": "you are stupid"})
print(response_without_moderation) moderated_chain = chain | moderate # Response after moderation
response_after_moderation = moderated_chain.invoke({"input": "you are stupid"})
print(response_after_moderation)
Selles näites on OpenAIModerationChain
kasutatakse LLM-i genereeritud vastuse modereerimise lisamiseks. Modereerimisahel kontrollib vastuseid sisule, mis rikub OpenAI sisupoliitikat. Kui leitakse rikkumisi, märgib see vastuse vastavalt.
Marsruutimine semantilise sarnasuse järgi
LCEL võimaldab teil rakendada kohandatud marsruutimise loogikat, mis põhineb kasutaja sisendi semantilisel sarnasusel. Siin on näide ahela loogika dünaamilisest määramisest kasutaja sisendi põhjal:
from langchain.chat_models import ChatOpenAI
from langchain.embeddings import OpenAIEmbeddings
from langchain.prompts import PromptTemplate
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.runnable import RunnableLambda, RunnablePassthrough
from langchain.utils.math import cosine_similarity physics_template = """You are a very smart physics professor. You are great at answering questions about physics in a concise and easy to understand manner. When you don't know the answer to a question you admit that you don't know. Here is a question:
{query}""" math_template = """You are a very good mathematician. You are great at answering math questions. You are so good because you are able to break down hard problems into their component parts, answer the component parts, and then put them together to answer the broader question. Here is a question:
{query}""" embeddings = OpenAIEmbeddings()
prompt_templates = [physics_template, math_template]
prompt_embeddings = embeddings.embed_documents(prompt_templates) def prompt_router(input): query_embedding = embeddings.embed_query(input["query"]) similarity = cosine_similarity([query_embedding], prompt_embeddings)[0] most_similar = prompt_templates[similarity.argmax()] print("Using MATH" if most_similar == math_template else "Using PHYSICS") return PromptTemplate.from_template(most_similar) chain = ( {"query": RunnablePassthrough()} | RunnableLambda(prompt_router) | ChatOpenAI() | StrOutputParser()
) print(chain.invoke({"query": "What's a black hole"}))
print(chain.invoke({"query": "What's a path integral"}))
Selles näites on prompt_router
funktsioon arvutab koosinuse sarnasuse kasutaja sisendi ja füüsika- ja matemaatikaküsimuste eelmääratletud viipamallide vahel. Sarnasuse skoori põhjal valib kett dünaamiliselt kõige asjakohasema viipamalli, tagades, et vestlusbot vastab kasutaja küsimusele õigesti.
Agentide ja käivitatavate failide kasutamine
LangChain võimaldab teil luua agente, kombineerides käivitatavaid elemente, viipasid, mudeleid ja tööriistu. Siin on näide agendi loomisest ja kasutamisest:
from langchain.agents import XMLAgent, tool, AgentExecutor
from langchain.chat_models import ChatAnthropic model = ChatAnthropic(model="claude-2") @tool
def search(query: str) -> str: """Search things about current events.""" return "32 degrees" tool_list = [search] # Get prompt to use
prompt = XMLAgent.get_default_prompt() # Logic for going from intermediate steps to a string to pass into the model
def convert_intermediate_steps(intermediate_steps): log = "" for action, observation in intermediate_steps: log += ( f"<tool>{action.tool}</tool><tool_input>{action.tool_input}" f"</tool_input><observation>{observation}</observation>" ) return log # Logic for converting tools to a string to go in the prompt
def convert_tools(tools): return "n".join([f"{tool.name}: {tool.description}" for tool in tools]) agent = ( { "question": lambda x: x["question"], "intermediate_steps": lambda x: convert_intermediate_steps( x["intermediate_steps"] ), } | prompt.partial(tools=convert_tools(tool_list)) | model.bind(stop=["</tool_input>", "</final_answer>"]) | XMLAgent.get_default_output_parser()
) agent_executor = AgentExecutor(agent=agent, tools=tool_list, verbose=True) result = agent_executor.invoke({"question": "What's the weather in New York?"})
print(result)
Selles näites luuakse agent mudeli, tööriistade, viipa ja vaheetappide ja tööriista teisendamise kohandatud loogika kombineerimise teel. Seejärel käivitatakse agent, mis annab vastuse kasutaja päringule.
SQL-andmebaasi päringu esitamine
LangChaini saate kasutada SQL-i andmebaasi päringute tegemiseks ja kasutajate küsimuste põhjal SQL-päringute genereerimiseks. Siin on näide:
from langchain.prompts import ChatPromptTemplate template = """Based on the table schema below, write a SQL query that would answer the user's question:
{schema} Question: {question}
SQL Query:"""
prompt = ChatPromptTemplate.from_template(template) from langchain.utilities import SQLDatabase # Initialize the database (you'll need the Chinook sample DB for this example)
db = SQLDatabase.from_uri("sqlite:///./Chinook.db") def get_schema(_): return db.get_table_info() def run_query(query): return db.run(query) from langchain.chat_models import ChatOpenAI
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.runnable import RunnablePassthrough model = ChatOpenAI() sql_response = ( RunnablePassthrough.assign(schema=get_schema) | prompt | model.bind(stop=["nSQLResult:"]) | StrOutputParser()
) result = sql_response.invoke({"question": "How many employees are there?"})
print(result) template = """Based on the table schema below, question, SQL query, and SQL response, write a natural language response:
{schema} Question: {question}
SQL Query: {query}
SQL Response: {response}"""
prompt_response = ChatPromptTemplate.from_template(template) full_chain = ( RunnablePassthrough.assign(query=sql_response) | RunnablePassthrough.assign( schema=get_schema, response=lambda x: db.run(x["query"]), ) | prompt_response | model
) response = full_chain.invoke({"question": "How many employees are there?"})
print(response)
Selles näites kasutatakse LangChaini SQL-päringute genereerimiseks kasutaja küsimuste põhjal ja vastuste toomiseks SQL-andmebaasist. Viibad ja vastused on vormindatud nii, et nad saaksid andmebaasiga suhelda loomulikus keeles.
Automatiseerige käsitsi ülesandeid ja töövooge meie AI-põhise töövoo koostajaga, mille on välja töötanud Nanonets teile ja teie meeskondadele.
LangServe ja LangSmith
LangServe aitab arendajatel juurutada LangChaini käivitatavaid faile ja ahelaid REST API-na. See teek on integreeritud FastAPI-ga ja kasutab andmete valideerimiseks pydantic'i. Lisaks pakub see klienti, mida saab kasutada serveris juurutatud käitatavatesse failidesse helistamiseks, ja JavaScripti klient on saadaval LangChainJS-is.
FUNKTSIOONID
- Sisend- ja väljundskeemid tuletatakse automaatselt teie LangChaini objektist ja jõustatakse iga API-kõne korral koos rikkalike veateadetega.
- Saadaval on API dokumentide leht JSONSchema ja Swaggeriga.
- Tõhusad /invoke, /batch ja /stream lõpp-punktid, mis toetavad paljusid samaaegseid päringuid ühes serveris.
- /stream_log lõpp-punkt kõigi (või mõne) vaheetappide voogesitamiseks teie ahelast/agendist.
- Mänguväljaku leht aadressil /playground voogesituse väljundi ja vahesammudega.
- LangSmithi sisseehitatud (valikuline) jälgimine; lihtsalt lisage oma API võti (vt juhiseid).
- Kõik on loodud lahingutestitud avatud lähtekoodiga Pythoni raamatukogudega, nagu FastAPI, Pydantic, uvloop ja asyncio.
Piirangud
- Kliendi tagasihelistamist ei toetata veel serverist pärinevate sündmuste puhul.
- Pydantic V2 kasutamisel OpenAPI dokumente ei genereerita. FastAPI ei toeta püdantiliste v1 ja v2 nimeruumide segamist. Lisateavet leiate allolevast jaotisest.
LangServe'i projekti kiireks käivitamiseks kasutage LangChaini CLI-d. Langchain CLI kasutamiseks veenduge, et teil oleks installitud langchain-cli uusim versioon. Saate selle installida käsuga pip install -U langchain-cli.
langchain app new ../path/to/directory
Käivitage oma LangServe'i eksemplar kiiresti LangChaini mallide abil. Rohkem näiteid leiate mallide registrist või näidete kataloogist.
Siin on server, mis kasutab OpenAI vestlusmudelit, antroopset vestlusmudelit ja ketti, mis kasutab Anthropic mudelit, et rääkida teemal nalja.
#!/usr/bin/env python
from fastapi import FastAPI
from langchain.prompts import ChatPromptTemplate
from langchain.chat_models import ChatAnthropic, ChatOpenAI
from langserve import add_routes app = FastAPI( title="LangChain Server", version="1.0", description="A simple api server using Langchain's Runnable interfaces",
) add_routes( app, ChatOpenAI(), path="/openai",
) add_routes( app, ChatAnthropic(), path="/anthropic",
) model = ChatAnthropic()
prompt = ChatPromptTemplate.from_template("tell me a joke about {topic}")
add_routes( app, prompt | model, path="/chain",
) if __name__ == "__main__": import uvicorn uvicorn.run(app, host="localhost", port=8000)
Kui olete ülaltoodud serveri juurutanud, saate loodud OpenAPI dokumente vaadata, kasutades:
curl localhost:8000/docs
Lisage kindlasti /docs järelliide.
from langchain.schema import SystemMessage, HumanMessage
from langchain.prompts import ChatPromptTemplate
from langchain.schema.runnable import RunnableMap
from langserve import RemoteRunnable openai = RemoteRunnable("http://localhost:8000/openai/")
anthropic = RemoteRunnable("http://localhost:8000/anthropic/")
joke_chain = RemoteRunnable("http://localhost:8000/chain/") joke_chain.invoke({"topic": "parrots"}) # or async
await joke_chain.ainvoke({"topic": "parrots"}) prompt = [ SystemMessage(content='Act like either a cat or a parrot.'), HumanMessage(content='Hello!')
] # Supports astream
async for msg in anthropic.astream(prompt): print(msg, end="", flush=True) prompt = ChatPromptTemplate.from_messages( [("system", "Tell me a long story about {topic}")]
) # Can define custom chains
chain = prompt | RunnableMap({ "openai": openai, "anthropic": anthropic,
}) chain.batch([{ "topic": "parrots" }, { "topic": "cats" }])
TypeScriptis (vajalik on LangChain.js versioon 0.0.166 või uuem):
import { RemoteRunnable } from "langchain/runnables/remote"; const chain = new RemoteRunnable({ url: `http://localhost:8000/chain/invoke/`,
});
const result = await chain.invoke({ topic: "cats",
});
Python kasutab päringuid:
import requests
response = requests.post( "http://localhost:8000/chain/invoke/", json={'input': {'topic': 'cats'}}
)
response.json()
Võite kasutada ka lokke:
curl --location --request POST 'http://localhost:8000/chain/invoke/' --header 'Content-Type: application/json' --data-raw '{ "input": { "topic": "cats" } }'
Järgmine kood:
...
add_routes( app, runnable, path="/my_runnable",
)
lisab serverisse järgmised lõpp-punktid:
- POST /my_runnable/invoke – käivitatav käivitatav fail ühes sisendis
- POST /my_käivitatav/partii – käivitab käivitatava sisendite partii
- POST /my_runnable/stream – käivitage ühes sisendis ja voogesitage väljund
- POST /my_runnable/stream_log – käivitage ühes sisendis ja voogesitage väljund, sealhulgas vahepealsete sammude väljund genereerimisel
- GET /my_runnable/input_schema – json-skeem käivitatavasse sisendisse
- GET /my_runnable/output_schema – json-skeem käivitatava väljundi jaoks
- GET /my_runnable/config_schema – Json-skeem käivitatava faili konfigureerimiseks
Mänguväljaku lehe oma runnable jaoks leiate aadressilt /my_runnable/playground. See avab lihtsa kasutajaliidese, mille abil saate konfigureerida ja käivitada voogesituse väljundi ja vahetoimingutega käivitatava faili.
Nii kliendi kui serveri jaoks:
pip install "langserve[all]"
või pip install “langserve[klient]” kliendikoodi jaoks ja pip install “langserve[server]” serveri koodi jaoks.
Kui teil on vaja oma serverile autentimist lisada, vaadake FastAPI turvadokumentatsiooni ja vahevara dokumentatsiooni.
Saate juurutada GCP Cloud Run, kasutades järgmist käsku:
gcloud run deploy [your-service-name] --source . --port 8001 --allow-unauthenticated --region us-central1 --set-env-vars=OPENAI_API_KEY=your_key
LangServe pakub Pydantic 2 tuge teatud piirangutega. Pydantic V2 kasutamisel OpenAPI dokumente ei genereerita invoke/batch/stream/stream_log jaoks. Fast API ei toeta püdantiliste v1 ja v2 nimeruumide segamist. LangChain kasutab Pydantic v1-s nimeruumi v2. LangChainiga ühilduvuse tagamiseks lugege läbi järgmised juhised. Välja arvatud need piirangud, eeldame, et API lõpp-punktid, mänguväljak ja muud funktsioonid töötavad ootuspäraselt.
LLM-rakendused tegelevad sageli failidega. Failide töötlemise rakendamiseks saab teha erinevaid arhitektuure; kõrgel tasemel:
- Faili saab serverisse üles laadida spetsiaalse lõpp-punkti kaudu ja töödelda eraldi lõpp-punkti abil.
- Faili võib üles laadida kas väärtuse (failibaidid) või viite järgi (nt faili sisu s3 URL).
- Töötlemise lõpp-punkt võib olla blokeeriv või mitteblokeeriv.
- Kui on vaja märkimisväärset töötlemist, võib töötluse maha laadida spetsiaalsesse protsessikogumisse.
Peaksite kindlaks määrama, milline on teie rakenduse jaoks sobiv arhitektuur. Praegu kasutage failide väärtuse järgi käivitatavasse üleslaadimiseks faili jaoks base64 kodeeringut (mitmeosalisi/vorm-andmeid veel ei toetata).
Siin näide mis näitab, kuidas kasutada base64 kodeeringut faili saatmiseks kaugkäivitatavasse. Pidage meeles, et saate faile alati üles laadida viite alusel (nt s3 URL) või üles laadida mitmeosaliste/vormiandmetena spetsiaalsesse lõpp-punkti.
Sisend- ja väljundtüübid on määratletud kõigil käivitatavatel failidel. Nendele pääsete juurde atribuutide input_schema ja output_schema kaudu. LangServe kasutab neid tüüpe valideerimiseks ja dokumenteerimiseks. Kui soovite vaikimisi tuletatud tüübid alistada, võite kasutada meetodit with_types.
Idee illustreerimiseks on näide mänguasjast:
from typing import Any
from fastapi import FastAPI
from langchain.schema.runnable import RunnableLambda app = FastAPI() def func(x: Any) -> int: """Mistyped function that should accept an int but accepts anything.""" return x + 1 runnable = RunnableLambda(func).with_types( input_schema=int,
) add_routes(app, runnable)
Pärige CustomUserType'ilt, kui soovite, et andmed deserialiseeritaks püdantilise mudelina, mitte samaväärseks dikteeritud esituseks. Praegu töötab see tüüp ainult serveri poolel ja seda kasutatakse soovitud dekodeerimiskäitumise määramiseks. Sellelt tüübilt pärimisel säilitab server dekodeeritud tüübi püdantilise mudelina, selle asemel, et seda diktaadiks teisendada.
from fastapi import FastAPI
from langchain.schema.runnable import RunnableLambda
from langserve import add_routes
from langserve.schema import CustomUserType app = FastAPI() class Foo(CustomUserType): bar: int def func(foo: Foo) -> int: """Sample function that expects a Foo type which is a pydantic model""" assert isinstance(foo, Foo) return foo.bar add_routes(app, RunnableLambda(func), path="/foo")
Mänguväljak võimaldab teil taustaprogrammis oma käivitatava jaoks kohandatud vidinaid määratleda. Vidin määratakse välja tasemel ja tarnitakse sisendtüübi JSON-skeemi osana. Vidin peab sisaldama võtit nimega tüüp, mille väärtus on üks tuntud vidinate loendist. Muud vidina võtmed seostatakse väärtustega, mis kirjeldavad JSON-objekti teid.
Üldskeem:
type JsonPath = number | string | (number | string)[];
type NameSpacedPath = { title: string; path: JsonPath }; // Using title to mimic json schema, but can use namespace
type OneOfPath = { oneOf: JsonPath[] }; type Widget = { type: string // Some well-known type (e.g., base64file, chat, etc.) [key: string]: JsonPath | NameSpacedPath | OneOfPath;
};
Võimaldab luua kasutajaliidese mänguväljakul failide üleslaadimise sisendi failidele, mis laaditakse üles base64 kodeeritud stringidena. Siin on täielik näide.
try: from pydantic.v1 import Field
except ImportError: from pydantic import Field from langserve import CustomUserType # ATTENTION: Inherit from CustomUserType instead of BaseModel otherwise
# the server will decode it into a dict instead of a pydantic model.
class FileProcessingRequest(CustomUserType): """Request including a base64 encoded file.""" # The extra field is used to specify a widget for the playground UI. file: str = Field(..., extra={"widget": {"type": "base64file"}}) num_chars: int = 100
Automatiseerige käsitsi ülesandeid ja töövooge meie AI-põhise töövoo koostajaga, mille on välja töötanud Nanonets teile ja teie meeskondadele.
Sissejuhatus LangSmithi
LangChain muudab LLM-rakenduste ja agentide prototüüpimise lihtsaks. LLM-i rakenduste tootmisse viimine võib aga olla petlikult keeruline. Kvaliteetse toote loomiseks peate tõenäoliselt oma viipasid, kette ja muid komponente põhjalikult kohandama ja kordama.
Selle protsessi hõlbustamiseks võeti kasutusele LangSmith, ühtne platvorm teie LLM-rakenduste silumiseks, testimiseks ja jälgimiseks.
Millal see kasuks võib tulla? See võib osutuda kasulikuks, kui soovite kiiresti siluda uut ketti, agenti või tööriistakomplekti, visualiseerida, kuidas komponendid (ahelad, llms-id, retriiverid jne) suhestuvad ja neid kasutatakse, hinnata ühe komponendi erinevaid viipasid ja LLM-e, Käitage antud ahelat mitu korda üle andmestiku, et tagada selle järjekindel vastavus kvaliteediribale, või jäädvustage kasutusjälgi ja kasutage statistika loomiseks LLM-e või analüütilisi torujuhtmeid.
Eeldused:
- Looge LangSmithi konto ja looge API võti (vt alumist vasakut nurka).
- Tutvuge platvormiga, vaadates dokumente.
Alustame nüüd!
Esiteks konfigureerige oma keskkonnamuutujad, et käskida LangChainil jälgi logida. Selleks määrake keskkonnamuutuja LANGCHAIN_TRACING_V2 väärtuseks Tõene. Saate määrata LangChainile, millisesse projekti logida, määrates keskkonnamuutuja LANGCHAIN_PROJECT (kui see pole määratud, logitakse käivitamised vaikeprojekti). See loob projekti automaatselt teie eest, kui seda pole olemas. Samuti peate määrama keskkonnamuutujad LANGCHAIN_ENDPOINT ja LANGCHAIN_API_KEY.
MÄRKUS. Pythonis saate jälgede logimiseks kasutada ka kontekstihaldurit, kasutades:
from langchain.callbacks.manager import tracing_v2_enabled with tracing_v2_enabled(project_name="My Project"): agent.run("How many people live in canada as of 2023?")
Kuid selles näites kasutame keskkonnamuutujaid.
%pip install openai tiktoken pandas duckduckgo-search --quiet import os
from uuid import uuid4 unique_id = uuid4().hex[0:8]
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_PROJECT"] = f"Tracing Walkthrough - {unique_id}"
os.environ["LANGCHAIN_ENDPOINT"] = "https://api.smith.langchain.com"
os.environ["LANGCHAIN_API_KEY"] = "<YOUR-API-KEY>" # Update to your API key # Used by the agent in this tutorial
os.environ["OPENAI_API_KEY"] = "<YOUR-OPENAI-API-KEY>"
API-ga suhtlemiseks looge LangSmithi klient:
from langsmith import Client client = Client()
Looge LangChaini komponent ja logi jookseb platvormile. Selles näites loome ReAct-stiilis agendi, millel on juurdepääs üldisele otsingutööriistale (DuckDuckGo). Agendi viipa saab vaadata keskuses siit:
from langchain import hub
from langchain.agents import AgentExecutor
from langchain.agents.format_scratchpad import format_to_openai_function_messages
from langchain.agents.output_parsers import OpenAIFunctionsAgentOutputParser
from langchain.chat_models import ChatOpenAI
from langchain.tools import DuckDuckGoSearchResults
from langchain.tools.render import format_tool_to_openai_function # Fetches the latest version of this prompt
prompt = hub.pull("wfh/langsmith-agent-prompt:latest") llm = ChatOpenAI( model="gpt-3.5-turbo-16k", temperature=0,
) tools = [ DuckDuckGoSearchResults( name="duck_duck_go" ), # General internet search using DuckDuckGo
] llm_with_tools = llm.bind(functions=[format_tool_to_openai_function(t) for t in tools]) runnable_agent = ( { "input": lambda x: x["input"], "agent_scratchpad": lambda x: format_to_openai_function_messages( x["intermediate_steps"] ), } | prompt | llm_with_tools | OpenAIFunctionsAgentOutputParser()
) agent_executor = AgentExecutor( agent=runnable_agent, tools=tools, handle_parsing_errors=True
)
Käitame agenti samaaegselt mitmel sisendil, et vähendada latentsust. Käitamised logitakse taustal LangSmithi sisse, nii et täitmise latentsusaeg ei muutu:
inputs = [ "What is LangChain?", "What's LangSmith?", "When was Llama-v2 released?", "What is the langsmith cookbook?", "When did langchain first announce the hub?",
] results = agent_executor.batch([{"input": x} for x in inputs], return_exceptions=True) results[:2]
Eeldades, et olete oma keskkonna edukalt seadistanud, peaksid teie agendijäljed ilmuma rakenduse jaotises Projektid. Õnnitlused!
Näib, et agent ei kasuta tööriistu siiski tõhusalt. Hindame seda, et saaksime lähtetaseme.
Lisaks logimistele võimaldab LangSmith teil testida ja hinnata ka oma LLM-i rakendusi.
Selles jaotises saate LangSmithi kasutada etalonandmete kogumi loomiseks ja AI-abiga hindajate käitamiseks agendil. Teete seda mõne sammuga.
- Looge LangSmithi andmestik:
Allpool kasutame LangSmithi klienti, et luua ülaltoodud sisendküsimustest ja loendi siltidest andmestik. Kasutate neid hiljem uue agendi toimivuse mõõtmiseks. Andmekogum on näidete kogum, mis pole midagi muud kui sisend-väljund paarid, mida saate kasutada oma rakenduse testjuhtumitena.
outputs = [ "LangChain is an open-source framework for building applications using large language models. It is also the name of the company building LangSmith.", "LangSmith is a unified platform for debugging, testing, and monitoring language model applications and agents powered by LangChain", "July 18, 2023", "The langsmith cookbook is a github repository containing detailed examples of how to use LangSmith to debug, evaluate, and monitor large language model-powered applications.", "September 5, 2023",
] dataset_name = f"agent-qa-{unique_id}" dataset = client.create_dataset( dataset_name, description="An example dataset of questions over the LangSmith documentation.",
) for query, answer in zip(inputs, outputs): client.create_example( inputs={"input": query}, outputs={"output": answer}, dataset_id=dataset.id )
- Võrdlusuuringu jaoks lähtestage uus agent:
LangSmith võimaldab teil hinnata mis tahes LLM-i, ketti, agenti või isegi kohandatud funktsiooni. Vestlusagendid on olekupõhised (neil on mälu); tagamaks, et seda olekut ei jagata andmestiku käitamise vahel, edastame ahela_factory (
aka konstruktor) funktsioon iga kõne jaoks lähtestamiseks:
# Since chains can be stateful (e.g. they can have memory), we provide
# a way to initialize a new chain for each row in the dataset. This is done
# by passing in a factory function that returns a new chain for each row.
def agent_factory(prompt): llm_with_tools = llm.bind( functions=[format_tool_to_openai_function(t) for t in tools] ) runnable_agent = ( { "input": lambda x: x["input"], "agent_scratchpad": lambda x: format_to_openai_function_messages( x["intermediate_steps"] ), } | prompt | llm_with_tools | OpenAIFunctionsAgentOutputParser() ) return AgentExecutor(agent=runnable_agent, tools=tools, handle_parsing_errors=True)
- Konfigureeri hindamine:
Kettide tulemuste käsitsi võrdlemine kasutajaliideses on tõhus, kuid võib võtta aega. Kasulik võib olla automaatsete mõõdikute ja tehisintellekti abil saadud tagasiside kasutamine, et hinnata oma komponendi jõudlust.
from langchain.evaluation import EvaluatorType
from langchain.smith import RunEvalConfig evaluation_config = RunEvalConfig( evaluators=[ EvaluatorType.QA, EvaluatorType.EMBEDDING_DISTANCE, RunEvalConfig.LabeledCriteria("helpfulness"), RunEvalConfig.LabeledScoreString( { "accuracy": """
Score 1: The answer is completely unrelated to the reference.
Score 3: The answer has minor relevance but does not align with the reference.
Score 5: The answer has moderate relevance but contains inaccuracies.
Score 7: The answer aligns with the reference but has minor errors or omissions.
Score 10: The answer is completely accurate and aligns perfectly with the reference.""" }, normalize_by=10, ), ], custom_evaluators=[],
)
- Käivitage agent ja hindajad:
Kasutage oma mudeli hindamiseks funktsiooni run_on_dataset (või asünkroonset arun_on_dataset). See teeb järgmist:
- Tooge näidisread määratud andmestikust.
- Käivitage oma agent (või mis tahes kohandatud funktsioon) iga näite puhul.
- Automatiseeritud tagasiside loomiseks rakendage tulemuseks olevatele käitamisjälgedele ja vastavatele võrdlusnäidetele hindajaid.
Tulemused on nähtavad LangSmithi rakenduses:
chain_results = run_on_dataset( dataset_name=dataset_name, llm_or_chain_factory=functools.partial(agent_factory, prompt=prompt), evaluation=evaluation_config, verbose=True, client=client, project_name=f"runnable-agent-test-5d466cbc-{unique_id}", tags=[ "testing-notebook", "prompt:5d466cbc", ],
)
Nüüd, kui meil on testimise tulemused, saame oma agendis muudatusi teha ja neid võrrelda. Proovime seda uuesti teise viipaga ja vaatame tulemusi:
candidate_prompt = hub.pull("wfh/langsmith-agent-prompt:39f3bbd0") chain_results = run_on_dataset( dataset_name=dataset_name, llm_or_chain_factory=functools.partial(agent_factory, prompt=candidate_prompt), evaluation=evaluation_config, verbose=True, client=client, project_name=f"runnable-agent-test-39f3bbd0-{unique_id}", tags=[ "testing-notebook", "prompt:39f3bbd0", ],
)
LangSmith võimaldab eksportida andmeid otse veebirakenduses levinud vormingutesse, nagu CSV või JSONL. Samuti saate klienti kasutada jooksude toomiseks edasiseks analüüsiks, oma andmebaasi salvestamiseks või teistega jagamiseks. Toome hindamisjooksust jooksujäljed:
runs = client.list_runs(project_name=chain_results["project_name"], execution_order=1) # After some time, these will be populated.
client.read_project(project_name=chain_results["project_name"]).feedback_stats
See oli kiire juhend alustamiseks, kuid LangSmithi kasutamiseks on arendajate voo kiirendamiseks ja paremate tulemuste saavutamiseks palju rohkem võimalusi.
Lisateavet selle kohta, kuidas saate LangSmithist maksimaalselt kasu saada, vaadake LangSmithi dokumentatsiooni.
Tase kõrgemale Nanonetsiga
Kuigi LangChain on väärtuslik tööriist keelemudelite (LLM-ide) integreerimiseks teie rakendustega, võib see ettevõttes esineda piirangutega. Uurime, kuidas Nanonets läheb LangChainist kaugemale, et lahendada järgmisi väljakutseid:
1. Põhjalik andmeside:
LangChain pakub konnektoreid, kuid see ei pruugi hõlmata kõiki tööruumi rakendusi ja andmevorminguid, millele ettevõtted tuginevad. Nanonets pakub andmeühendusi enam kui 100 laialdaselt kasutatavale tööruumirakendusele, sealhulgas Slack, Notion, Google Suite, Salesforce, Zendesk ja palju muud. Samuti toetab see kõiki struktureerimata andmetüüpe, nagu PDF-id, TXT-d, pildid, helifailid ja videofailid, aga ka struktureeritud andmetüüpe, nagu CSV-d, arvutustabelid, MongoDB ja SQL-andmebaasid.
2. Tööruumi rakenduste ülesannete automatiseerimine:
Kuigi teksti / vastuse genereerimine töötab suurepäraselt, on LangChaini võimalused loomuliku keele kasutamisel erinevates rakendustes ülesannete täitmiseks piiratud. Nanonets pakub kõige populaarsemate tööruumirakenduste jaoks käivitus-/toiminguagente, mis võimaldavad teil seadistada töövooge, mis kuulavad sündmusi ja sooritavad toiminguid. Näiteks saate automatiseerida e-posti vastuseid, CRM-i kirjeid, SQL-päringuid ja palju muud, kõike seda loomuliku keele käskude abil.
3. Andmete reaalajas sünkroonimine:
LangChain tõmbab staatilisi andmeid andmekonnektoritega, mis ei pruugi lähteandmebaasi andmemuudatustega sammu pidada. Seevastu Nanonets tagab reaalajas sünkroonimise andmeallikatega, tagades, et töötate alati uusima teabega.
3. Lihtsustatud konfiguratsioon:
LangChaini konveieri elementide (nt retriiverid ja süntesaatorid) seadistamine võib olla keeruline ja aeganõudev protsess. Nanonets muudab selle sujuvamaks, pakkudes iga andmetüübi jaoks optimeeritud andmete sissevõtmist ja indekseerimist, mida kõike taustal haldab AI-assistent. See vähendab peenhäälestamise koormust ning muudab seadistamise ja kasutamise lihtsamaks.
4. Ühtne lahendus:
Erinevalt LangChainist, mis võib nõuda iga ülesande jaoks ainulaadseid rakendusi, on Nanonets ühtne lahendus teie andmete ühendamiseks LLM-idega. Olenemata sellest, kas teil on vaja luua LLM-i rakendusi või AI töövooge, pakub Nanonets ühtset platvormi teie erinevate vajaduste jaoks.
Nanonetsi AI töövood
Nanonets Workflows on turvaline mitmeotstarbeline tehisintellekti assistent, mis lihtsustab teie teadmiste ja andmete integreerimist LLM-idega ning hõlbustab koodita rakenduste ja töövoogude loomist. See pakub lihtsalt kasutatavat kasutajaliidest, muutes selle kättesaadavaks nii üksikisikutele kui ka organisatsioonidele.
Alustamiseks saate kokku leppida kõne mõne meie AI-eksperdiga, kes võib pakkuda teie konkreetsele kasutusjuhtumile kohandatud Nanonetsi töövoogude isikupärastatud demo ja prooviversiooni.
Pärast seadistamist saate kasutada loomulikku keelt keerukate rakenduste ja töövoogude kujundamiseks ja käivitamiseks, mis töötavad LLM-idel, integreerides need sujuvalt oma rakenduste ja andmetega.
Täiendage oma meeskondi Nanonets AI-ga, et luua rakendusi ja integreerida oma andmed AI-põhiste rakenduste ja töövoogudega, võimaldades teie meeskondadel keskenduda tõeliselt olulisele.
Automatiseerige käsitsi ülesandeid ja töövooge meie AI-põhise töövoo koostajaga, mille on välja töötanud Nanonets teile ja teie meeskondadele.
- SEO-põhise sisu ja PR-levi. Võimenduge juba täna.
- PlatoData.Network Vertikaalne generatiivne Ai. Jõustage ennast. Juurdepääs siia.
- PlatoAiStream. Web3 luure. Täiustatud teadmised. Juurdepääs siia.
- PlatoESG. Süsinik, CleanTech, Energia, Keskkond päikeseenergia, Jäätmekäitluse. Juurdepääs siia.
- PlatoTervis. Biotehnoloogia ja kliiniliste uuringute luureandmed. Juurdepääs siia.
- Allikas: https://nanonets.com/blog/langchain/
- :on
- :on
- :mitte
- : kus
- $ UP
- 1
- 10
- 100
- 114
- 13
- 15%
- 2000
- 2012
- 2023
- 25
- 30
- 32
- 36
- 40
- 400
- 408
- 50
- 500
- 7
- 8
- a
- ABC
- võime
- Võimalik
- MEIST
- sellest
- üle
- aktsepteerima
- Nõustub
- juurdepääs
- juurdepääsetav
- Ligipääs
- täitma
- vastavalt
- konto
- täpsus
- täpne
- täpselt
- Saavutada
- saavutada
- Saavutab
- üle
- tegu
- tegevus
- meetmete
- aktiivne
- kohanemine
- adaptiivne
- lisama
- lisatud
- lisades
- lisamine
- Täiendavad lisad
- Lisaks
- aadress
- Lisab
- tunnistama
- edasijõudnud
- seiklus
- pärast
- jälle
- vanus
- Agent
- ained
- AI
- AI assistent
- AI mudelid
- Abi
- Eesmärk
- algoritme
- viia
- Joondab
- Materjal: BPA ja flataatide vaba plastik
- võimaldama
- Lubades
- võimaldab
- üksi
- mööda
- kõrval
- juba
- Ka
- Kuigi
- alati
- an
- analüüs
- Analüütiline
- analytics
- ja
- Angeles
- Teatama
- aastane
- Teine
- vastus
- vastuseid
- hümn
- Antroopne
- mistahes
- midagi
- API
- API VÕTMED
- API-liidesed
- app
- kohaldatav
- taotlus
- Sovelluskehitys
- rakendused
- rakendatud
- kehtib
- lähenemine
- lähenemisviisid
- asjakohane
- asjakohaselt
- apps
- arhitektuur
- OLEME
- argument
- argumendid
- Armstrong
- ümber
- Array
- Kunstnikud
- AS
- küsima
- aspekt
- aspektid
- abistama
- assistent
- seotud
- At
- kinnitage
- tähelepanu
- heli-
- suurendatud
- Autentimine
- automatiseerima
- Automatiseeritud
- automatiseerib
- automaatselt
- Automaatika
- saadaval
- keskmine
- ootama
- teadlik
- AWS
- tagasi
- Selgroog
- Taustaprogramm
- tagapõhi
- halvasti
- Saldo
- baar
- baas
- põhineb
- Baseline
- sisse lööma
- põhiline
- Alused
- BCG
- BE
- rand
- Karud
- sest
- olnud
- enne
- alustama
- käitumine
- taga
- kaamerate taga
- on
- alla
- võrrelda
- kasulik
- BEST
- Parem
- vahel
- Peale
- suurim
- arve
- Bill Gates
- siduda
- Bing
- Natuke
- Must
- Must auk
- Blokeerima
- blokeerimine
- Plokid
- Blogi
- tera
- Bootstrap
- sündinud
- Bot
- mõlemad
- põhi
- Filiaal
- Murdma
- tuul
- lühidalt
- laiem
- pruun
- brauseri
- puhver
- ehitama
- ehitaja
- Ehitus
- ehitatud
- koormus
- ettevõtted
- kuid
- by
- arvutama
- arvutab
- arvutamisel
- arvutus
- helistama
- tagasihelistamine
- kutsutud
- kutsudes
- Kutsub
- CAN
- Saab
- Kanada
- võimeid
- võimeline
- Võimsus
- lüüa
- Püüdmine
- juhul
- juhtudel
- CAT
- rahuldada
- toitlustamine
- näeb ette
- Kassid
- ettevaatust
- ettevaatlik
- keskele
- kindel
- kett
- ketid
- väljakutseid
- Vaidluste lahendamine
- iseloom
- chatbot
- jututoad
- kontrollima
- Kontroll
- Vali
- valitud
- asjaolusid
- Linn
- klass
- klassid
- klient
- Cloud
- kood
- Kodeerimine
- Kohv
- SIDUS
- ühtehoidev
- Teevad koostööd
- Kokkuvarisemine
- kogumine
- värvikas
- Veerg
- Veerud
- COM
- ühendama
- kombineeritud
- ühendab
- kombineerimine
- Tulema
- tuleb
- mugav
- ühine
- KOMMUNIKATSIOON
- ettevõte
- võrdlema
- võrrelda
- ühilduvus
- kokkusobiv
- täitma
- täiesti
- lõpetamist
- keeruline
- keerukust
- komponent
- komponendid
- koostatud
- koostis
- terviklik
- koosnevad
- mõiste
- lühike
- konkurent
- seisund
- konfiguratsioon
- ühinemine
- Võta meiega ühendust
- ühendamine
- Side
- Miinused
- Arvestama
- järjepidevalt
- koosneb
- konsool
- pidevalt
- konstrueerib
- sisaldama
- sisaldab
- sisu
- kontekst
- kontekstid
- kontekstuaalne
- jätkama
- pidevalt
- kontrast
- kontrollida
- kontrolli
- Mugav
- Vestlus
- jutukas
- jutukas AI
- vestlused
- Konverteerimine
- ümber
- konverteeriva
- tuum
- Nurk
- parandada
- Vastav
- võiks
- loendamine
- riik
- Paar
- cover
- kaetud
- looma
- loodud
- loob
- loomine
- loomine
- volikiri
- kriteeriumid
- Kriitik
- CRM
- otsustav
- Praegune
- Praegu
- tava
- Kliendid
- kohandamine
- kohandada
- kohandatud
- viimase peal
- andmed
- Andmete struktuur
- andmebaas
- andmebaasid
- kuupäev
- kuupäev Kellaaeg
- tegelema
- tegelema
- Detsember
- otsustama
- Otsustamine
- Otsuse tegemine
- dekodeerimine
- pühendunud
- sügavam
- vaikimisi
- määratlema
- määratletud
- määratlemisel
- mõisted
- edastamine
- annab
- süvenema
- demo
- näitama
- Näidatud
- näidates
- sõltuvad
- Olenevalt
- sõltub
- juurutada
- lähetatud
- juurutamine
- kasutuselevõtu
- juurutab
- kirjeldama
- kirjeldus
- Disain
- määratud
- kavandatud
- soovitud
- detail
- üksikasjalik
- detailid
- Määrama
- määrab
- arendama
- arendaja
- Arendajad
- arenev
- & Tarkvaraarendus
- diagrammid
- DIKT
- DID
- erinevad
- erinev
- erinevalt
- raske
- mõõde
- mõõdud
- direktiivid
- otse
- arutama
- arutatud
- väljapanek
- eristatav
- sukelduma
- mitu
- DM
- do
- dokument
- dokumentatsioon
- dokumendid
- ei
- ei
- teeme
- don
- tehtud
- kahekordistada
- alla
- lae alla
- allalaadimine
- eelnõu
- ajam
- kaks
- ajal
- dünaamiline
- dünaamiliselt
- e
- iga
- Ajalugu
- Varajane
- leevendada
- kasutusmugavus
- lihtsam
- kergesti
- lihtne
- lihtne-to-use
- miss
- ökosüsteemi
- Tõhus
- tõhusalt
- efektiivsus
- tõhus
- tõhusalt
- sundimatult
- kumbki
- element
- elemendid
- Elon
- Elon Musk
- teine
- Embed
- varjatud
- kinnistamine
- töötavad
- töötajad
- töötab
- volitama
- võimaldama
- võimaldab
- võimaldades
- kapseldab
- kohtumine
- Lõpuks-lõpuni
- Lõpp-punkt
- kaasamine
- Mootor
- Mootorid
- Inglismaa
- Inglise
- English Premier League
- suurendama
- tõhustatud
- suurendamine
- tagama
- tagab
- tagades
- ettevõte
- üksuste
- üksus
- keskkond
- keskkondades
- Samaväärne
- Ajastu
- viga
- vead
- eriti
- oluline
- võõrandunud
- jms
- hindama
- hindamine
- Isegi
- sündmused
- Iga
- näide
- näited
- ületama
- Välja arvatud
- täitma
- täidetud
- Täidab
- hukkamine
- täitmine
- eeskujuks
- Teostama
- eksisteerima
- ootama
- ootused
- oodatav
- ootab
- kogemus
- eksperimentaalne
- ekspertide
- selgitas
- Selgitab
- selgesõnaliselt
- uurimine
- uurima
- uurida
- eksport
- väljend
- laiendama
- laiendades
- ulatuslik
- väline
- lisatasu
- väljavõte
- kaevandamine
- Väljavõtted
- nägu
- hõlbustada
- hõlbustab
- tehas
- andmed
- kaugele
- KIIRE
- Lemmik
- tunnusjoon
- FUNKTSIOONID
- tagasiside
- vähe
- väli
- Valdkonnad
- figma
- Joonis
- fail
- Faile
- täitma
- täidetud
- täitmine
- filtreerida
- filtreerimine
- lõplik
- Lõpuks
- leidma
- leidmine
- esimene
- viis
- Paindlikkus
- paindlik
- voog
- Keskenduma
- keskendunud
- keskendub
- keskendumine
- järgima
- Järel
- järgneb
- toit
- eest
- vorm
- formaat
- moodustatud
- Õnneks
- avastatud
- Raamistik
- raamistikud
- sageli
- sõber
- sõbrad
- Alates
- täis
- täieõiguslik
- funktsioon
- funktsionaalsused
- funktsionaalsus
- funktsioonid
- põhiline
- naljakas
- edasi
- tulevik
- kasu
- Mängud
- Gates
- Üldine
- üldiselt
- tekitama
- loodud
- genereerib
- teeniva
- põlvkond
- žanr
- Saksamaa
- saama
- saamine
- gif
- GitHub
- antud
- GMT
- Go
- Goes
- läheb
- hea
- granuleeritud
- graafik
- suur
- suurem
- juhised
- suunata
- suunised
- häkkimismaraton
- käepide
- Varred
- Käsitsemine
- mugav
- Raske
- kahju
- rakmed
- Olema
- võttes
- tugevalt
- Held
- aitama
- kasulik
- aitab
- siin
- siin
- hi
- Suur
- kõrgetasemeline
- kvaliteetne
- kõrgeim
- kõrgelt
- ajalooline
- ajalugu
- Auk
- kapuuts
- võõrustaja
- Kuidas
- Kuidas
- aga
- HTML
- http
- HTTPS
- Keskus
- inim-
- sajad
- i
- ID
- idee
- ideaalne
- IDd
- if
- ii
- iii
- Illustreerima
- illustreerib
- pildid
- Vahetu
- rakendada
- täitmine
- rakendused
- rakendatud
- import
- parandusi
- Paranemist
- in
- sügavuti minev
- sisaldama
- lisatud
- hõlmab
- Kaasa arvatud
- lisada
- kaasates
- uskumatult
- indeks
- indeksid
- näitama
- näitab
- Üksikult
- inimesed
- info
- esialgne
- algatama
- uuenduslik
- sisend
- sisendite
- teadmisi
- paigaldama
- paigaldatud
- paigaldamine
- Näiteks
- kiire
- selle asemel
- juhised
- lahutamatu
- integreerima
- integreeritud
- Integreerib
- Integreerimine
- integratsioon
- integratsioon
- Intelligentne
- ette nähtud
- suhelda
- suhtlemist
- interaktsioonid
- interaktiivne
- interaktiivne
- Interface
- liidesed
- sisemiselt
- Internet
- sisse
- sisse
- Tutvustab
- intuitiivne
- kaasates
- pole
- probleem
- küsimustes
- IT
- kirjed
- kordused
- ITS
- ise
- Jackson
- JavaScript
- töö
- Jordaania
- teekond
- Json
- Juuli
- lihtsalt
- Õiglus
- hoidma
- hoiab
- Võti
- võtmed
- Laps
- Teadma
- teadmised
- Teadmised graafik
- teatud
- silt
- Labels
- maa
- keel
- Keeled
- suur
- suurem
- viimane
- Hilinemine
- pärast
- hiljemalt
- Liiga
- Õppida
- õppimine
- lahkus
- Pärand
- Pikkus
- vähem
- laskma
- Lets
- kiri
- Tase
- taset
- Finantsvõimendus
- võimendab
- võimendav
- raamatukogud
- Raamatukogu
- nagu
- Tõenäoliselt
- LIMIT
- piirangud
- piiratud
- piirav
- piirid
- lingid
- nimekiri
- kuulama
- Nimekirjad
- elama
- ll
- LLM
- koormus
- laadur
- asub
- liising
- logi
- loginud
- metsaraie
- loogika
- Pikk
- enam
- Vaata
- otsin
- välimus
- lookup
- a
- Los Angeles
- Madal
- masin
- masinõpe
- tehtud
- säilitada
- Hooldatav
- säilitamine
- jääb
- tegema
- TEEB
- Tegemine
- juhtima
- juhtimine
- juht
- juhtiv
- Manchester
- Manchester United
- Manipuleerimine
- viis
- käsiraamat
- Tootja
- palju
- palju inimesi
- kaart
- kaardistus
- kaardid
- Vastama
- sobitamine
- matemaatika
- matemaatiline
- Oluline
- maksimaalne
- mai..
- me
- keskmine
- tähendus
- vahendid
- mõõtma
- Meedia
- koosolekul
- vastab
- Mälestused
- Mälu
- mainitud
- Merge
- ühinevad
- sõnum
- kirjad
- Sõnumid
- Metaandmed
- meetod
- meetodid
- Meetrika
- võib
- miljonid
- minimaalne
- alaealine
- puuduvad
- vigu
- Segamine
- MLB
- mobiilne
- mudel
- mudelid
- mõõdukus
- moodulid
- Moodulid
- hetk
- MongoDB
- Jälgida
- järelevalve
- Moon
- rohkem
- kõige
- Populaarseim
- liikuma
- film
- palju
- mitmekordne
- mitu ahelat
- Musk
- peab
- my
- nimi
- Nimega
- nimed
- riiklik
- Natural
- Natural Language Processing
- Navigate
- navigeerimine
- Lähedal
- vajalik
- Vajadus
- vaja
- vajadustele
- negatiivne
- Uus
- New York
- New York Timesile
- järgmine
- ei
- mitte ükski
- mitte midagi
- Mõiste
- nüüd
- number
- Obama
- objekt
- eesmärk
- esemeid
- tähelepanek
- saama
- saamine
- OCR
- of
- pakkuma
- pakkumine
- Pakkumised
- sageli
- oh
- Hästi
- olümpiamängud
- on
- kunagi
- ONE
- ainult
- avatud lähtekoodiga
- OpenAI
- Operations
- operaator
- optimeeritud
- Optimeerib
- valik
- or
- et
- orgaaniline
- organisatsioonid
- originaal
- OS
- Muu
- teised
- muidu
- meie
- välja
- väljund
- väljundid
- üle
- ignoreerimine
- ülevaade
- enda
- pakend
- pakette
- lehekülg
- lehekülge
- paari
- pandas
- Paber
- Parallel
- parameeter
- parameetrid
- park
- osa
- eriti
- osad
- sooritama
- Vastu võetud
- möödub
- Mööduv
- minevik
- tee
- teed
- mustrid
- Palgaarvestus
- Inimesed
- kohta
- täiuslik
- suurepäraselt
- täitma
- jõudlus
- esitades
- täidab
- Õigused
- püsivus
- inimene
- Isikliku
- perspektiiv
- Füüsika
- tükk
- torujuhe
- pitsa
- kohatäide
- inimesele
- Platon
- Platoni andmete intelligentsus
- PlatoData
- mängima
- mänguväljak
- mängib
- palun
- pluss
- Punkt
- Poliitika
- poliitika
- poliitiline
- ujula
- populaarne
- asustatud
- positiivne
- võimalik
- post
- Postitusi
- potentsiaal
- võim
- sisse
- võimas
- Praktiline
- tava
- eelistama
- peaminister
- esitada
- president
- vältida
- ennetada
- eelmine
- eelkõige
- esmane
- Peamine
- era-
- Probleem
- probleeme
- jätkama
- protsess
- Töödeldud
- Protsessid
- töötlemine
- tootma
- Toode
- Produktsioon
- Õpetaja
- Programming
- programmeerimiskeeled
- projekt
- projektid
- omadused
- kinnisvara
- PROS
- prototüüp
- prototüüpimine
- anda
- tingimusel
- tarnija
- pakkujad
- annab
- pakkudes
- avalik
- eesmärk
- eesmärkidel
- panema
- Python
- Küsimused ja vastused
- kvaliteet
- päringud
- küsimus
- Küsimused
- Kiire
- kiiresti
- quotes
- R
- tõstma
- valik
- alates
- pigem
- hinnang
- Töötlemata
- RE
- jõudma
- Reageerima
- Lugenud
- Lugemine
- valmis
- reaalne
- reaalajas
- reaalajas andmeid
- realm
- põhjus
- põhjustel
- hiljuti
- soovitatav
- dokumenteeritud
- andmed
- Taastuma
- vähendama
- vähendab
- vähendamine
- vähendamine
- viide
- viitamine
- filtreeri
- rafineerimine
- piirkondades
- Suhted
- vabastatud
- asjakohasus
- asjakohane
- usaldusväärsus
- usaldusväärne
- lootma
- tuginedes
- jäänused
- meeles pidama
- meeldetuletus
- kauge
- saagis
- kordama
- KORDUVALT
- ümbersõnastamist
- asendama
- aru
- Hoidla
- esindamine
- esindavad
- esindab
- taotleda
- Taotlusi
- nõudma
- nõutav
- Nõuded
- Vajab
- päästma
- teadustöö
- lahendama
- ressurss
- Reageerida
- vastates
- vastus
- vastuste
- vastutav
- tundlik
- REST
- kaasa
- tulemuseks
- Tulemused
- säilitamine
- säilitamine
- tagasipöördumine
- tagasi
- Tulu
- korduvkasutatav
- läbi
- pöörleb
- riis
- Rikas
- robotid
- Roll
- rollid
- juur
- Marsruutimine
- ROW
- jooks
- jooksmine
- jookseb
- runtime
- s
- tagatisi
- müük
- müügijõud
- Sam
- sama
- Säästa
- ütlema
- ütleb
- skaalautuvia
- Skaala
- stsenaarium
- stsenaariumid
- stseenide
- ajakava
- skoor
- kriimustada
- sujuv
- sujuvalt
- Otsing
- otsingumootor
- otsingud
- otsimine
- Osa
- lõigud
- kindlustama
- turvalisus
- vaata
- väljavalitud
- valik
- Müük
- saatma
- tundlik
- tunne
- tunded
- eri
- September
- Jada
- Seeria
- teenima
- server
- teenib
- Teenused
- komplekt
- Komplektid
- kehtestamine
- seaded
- seade
- seitse
- mitu
- Jaga
- jagatud
- Shell
- särab
- veetud
- peaks
- näitama
- presentatsioon
- näidatud
- Näitused
- Sigma
- märkimisväärne
- sarnane
- lihtne
- lihtsustatud
- lihtsustama
- lihtsustamine
- lihtsalt
- alates
- ühekordne
- SUURUS
- nõrk
- väike
- väiksem
- nutikas
- jupp
- So
- nii kaugel
- jalgpall
- sotsiaalmeedia
- Sotsiaalse meedia
- Sotsiaalmeedia postitused
- Ainult
- tahke
- lahendus
- LAHENDAGE
- mõned
- midagi
- mõnikord
- keeruline
- helid
- allikas
- Allikad
- Ruum
- hispaania
- spetsialiseeritud
- konkreetse
- eriti
- spetsiifikat
- määratletud
- kiirus
- kasutatud
- jagada
- Poolitab
- Sport
- ruut
- seisma
- standalone
- standard
- algus
- alustatud
- Käivitus
- riik
- avaldused
- staatiline
- Samm
- Sammud
- Veel
- Peatus
- peatumine
- Peatab
- ladustamine
- salvestada
- ladustatud
- kauplustes
- ladustamine
- Lugu
- lihtne
- oja
- streaming
- kiirendama
- Sujuvamaks
- tugevused
- Streigid
- nöör
- struktuur
- struktureeritud
- struktuuride
- struktureerimine
- stiil
- teema
- järgnev
- Edukalt
- selline
- Kostüüm
- sobiv
- komplekt
- Kokku võtta
- KOKKUVÕTE
- Päikeseloojang
- toetama
- Toetatud
- Toetab
- kindel
- Jätkusuutlikkus
- Sünkroonimine
- ülevaade
- süntaks
- süsteem
- süsteemid
- tabel
- sobivalt
- kohandatud
- Võtma
- võtab
- eesmärgid
- Ülesanne
- ülesanded
- meeskond
- meeskonnad
- öelda
- šabloon
- malle
- terminal
- terminoloogia
- tingimused
- test
- Testimine
- tekst
- kui
- tänan
- et
- .
- Põhitõed
- jaotur
- teave
- The New York Times
- Projektid
- Allikas
- maailm
- oma
- Neile
- SIIS
- Seal.
- Need
- nad
- asjad
- see
- need
- kuigi?
- Läbi
- läbi kogu
- aeg
- aega võttev
- korda
- Kapslid
- et
- kokku
- sümboolne
- Tokeniseerimine
- märgid
- liiga
- tööriist
- Käsiraamat
- töövahendid
- ülemine
- teema
- Teemasid
- Summa
- linn
- Jälgimine
- jälgida
- traditsiooniline
- koolitus
- Muutma
- muundumised
- trafo
- trafod
- üleminek
- kohtuprotsess
- tõsi
- tõeliselt
- püüdma
- häälestamine
- Pöörake
- Pööramine
- juhendaja
- Kaks korda
- kaks
- tüüp
- liigid
- Masinakiri
- tüüpiliselt
- ui
- lõpuks
- puutumata
- all
- aluseks
- mõistma
- mõistmine
- mõistab
- ühtne
- ainulaadne
- Ühendatud
- Universaalne
- erinevalt
- kuni
- Värskendused
- Uudised
- laetud
- URL
- us
- kasutatavus
- Kasutus
- kasutama
- kasutage juhtumit
- Kasutatud
- Kasutaja
- Kasutajaliides
- Kasutajad
- kasutusalad
- kasutamine
- kommunaalteenused
- ära kasutama
- kasutatud
- kasutab ära
- kasutades
- v1
- kinnitamine
- Validator
- väärtuslik
- väärtus
- Väärtused
- muutuja
- sort
- eri
- Ve
- mitmekülgne
- versioon
- väga
- kaudu
- Video
- vaade
- Rikkumised
- nähtav
- visualiseeri
- tähtis
- vs
- kõndima
- läbikäiguks
- tahan
- oli
- Watch
- Tee..
- kuidas
- we
- ilm
- web
- veebibrauseri
- veebiteenused
- veebilehed
- Hästi
- hästi tuntud
- olid
- M
- Mis on
- whats
- millal
- kas
- mis
- kuigi
- WHO
- kogu
- miks
- lai
- laialdaselt
- vidina
- Wikipedia
- will
- aken
- Võidud
- koos
- jooksul
- ilma
- sõna
- Töö
- töötas
- töövoog
- Töövoogud
- töö
- töötab
- maailm
- oleks
- kirjutama
- kirjutamine
- X
- veel
- york
- sa
- Sinu
- ise
- youtube
- Zendesk
- sephyrnet
- Tõmblukk