Iniziare con Langchain per i principianti

I modelli di linguaggio di grandi dimensioni (LLM) come GPT-4 di Openi e i modelli facciali abbracciati sono potenti, ma usarli in modo efficace nelle applicazioni richiede di più che semplicemente chiamare un’API. Langchain è un framework che semplifica il lavoro con LLM, consentendo agli sviluppatori di creare facilmente applicazioni AI avanzate.

In questo articolo, tratteremo:

Cos’è Langchain?
Come installare e configurare Langchain
Utilizzo di base: Entry OpenAI LLLS, LLMS su faccia abbracciata, modelli immediate, catene
Un semplice esempio di chatbot di Langchain

Cos’è Langchain?

Langchain è un framework open supply progettato per aiutare gli sviluppatori a costruire applicazioni alimentate da LLM. Fornisce strumenti per strutturare le interazioni LLM, gestire la memoria, integrare le API e creare flussi di lavoro complessi.

Vantaggi di Langchain

Semplifica la gestione di istruzioni e risposte
Supporta più supplier LLM (openi, faccia abbraccio, antropico, ecc.)
Abilita la memoria, il recupero e il concatenamento di più chiamate di intelligenza artificiale
Supporta la costruzione di chatbot, agenti e app basate sull’intelligenza artificiale

Una guida passo-passo

Passaggio 1: installazione

Per iniziare, installa il pacchetto API di Langchain e Openi utilizzando PIP, apri il tuo terminale ed esegui il seguente comando:

pip set up langchain langchain_openai openai

Imposta la chiave API in una variabile di ambiente:

import os
os.environ("OPENAI_API_KEY") = "your-api-key-here"

Passaggio 2: usando la chatopenai di Langchain

Ora, usiamo il modello di Openai per generare testo.

Esempio di base: generazione di una risposta

from langchain_openai import ChatOpenAI

# Initialize the mannequin
llm = ChatOpenAI(mannequin="gpt-3.5-turbo", temperature=0.5)

# write your immediate
immediate = "What's LangChain ?"

# print the response
print(llm.invoke(immediate))

Spiegazione

from langchain_openai import ChatOpenAI(). Questo importa il ChatOpenAI classe dal langchain_openai pacchetto e consente di utilizzare Modelli basati su GPT di Openi per AI conversazionale.
ChatOpenAI(). Questo inizializza il modello GPT.
mannequin ="gpt-3.5-turbo". Poiché l’IA aperta ha diversi modelli da utilizzare, dobbiamo passare il modello che vogliamo utilizzare per una risposta rapida. Tuttavia, per impostazione predefinita, APEN AI utilizza il text-davinci-003 modello.
temperaure=0.5. Chatopenai è inizializzato con una temperatura di 0,5. La temperatura controlla la casualità nella risposta:
- 0.0: Deterministico (restituisce sempre lo stesso output per lo stesso enter).
- 0.7: Risposte più inventive/casuali.
- 1.0: Risposte altamente casuali e imprevedibili.
- Poiché la temperatura = 0,5, si bilancia tra creatività e affidabilità.
immediate = "What's LangChain?". Qui, stiamo definendo il immediate, che proviene da Langchain e verrà inviato al modello Chatopenai per l’elaborazione.
llm.invoke(immediate). Questo invia il immediate al LLM dato e ottiene la risposta.

Passaggio 3: utilizzando altri modelli LLM usando HuggingFacepipeline

from langchain_huggingface import HuggingFacePipeline

# Initialize the mannequin, right here are attempting to make use of this mannequin - google/flan-t5-base

llm = HuggingFacePipeline.from_model_id(
    model_id="google/flan-t5-base",
    activity="text-generation",
    pipeline_kwargs={"max_new_tokens": 200, "temperature" :0.1},
)

# print the response
print(llm.invoke("What's Deep Studying?"))


# In abstract right here we discovered about utilizing completely different llm utilizing langchain,
# as a substitute OpenAI we used a mannequin on Huggingface. 
# This helps us to work together with fashions uploaded by neighborhood.

Passaggio 4: proseguimenti di incapaci con LLMS

Langchain consente di collegare istruzioni e modelli in catene.

# Prompts template and chaining utilizing langchain
from langchain.prompts import PromptTemplate
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model_name="gpt-4o",temperature=0.9)

# Immediate Template - allow you to generate prompts that accepts variable, 
# we are able to have a number of variables as properly
template = "What's the impression on my well being, if I eat {meals} and drink {drink}?"
immediate = PromptTemplate.from_template(template)

# Right here chains comes into image to transcend single llm name 
# and contain sequence of llm calls, and chains llms and immediate togetger
# Now we initialize our chain with immediate and llm mannequin reference
chain = immediate | llm

# right here we're invok the chain with meals parameter as Bread and drink parameter as wine.
print(chain.invoke({"meals" : "Bread","drink":"wine"}))

Perché usare Langchain?

Automatizza il processo di formattazione dei immediate
Aiuta i flussi di lavoro in più fasi
Fa codice modulare E scalabile

Passaggio 5: catene più attività in una sequenza

Le catene di Langchain consentono di combinare più catene, dove l’uscita della prima catena può essere utilizzata come enter alla seconda catena.

from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI
from langchain.prompts import PromptTemplate

llm = ChatOpenAI(model_name="gpt-4o", temperature=0)

#first template and chain
template = "Which is probably the most {adjectective} constructing on the earth ?"
immediate = PromptTemplate.from_template(template)
chain = immediate | llm | StrOutputParser()

#second template and chain with the primary chain
template_second = "Inform me extra in regards to the {constructing}?"
prompt_second = PromptTemplate.from_template(template_second)
chain_second = {"noun" : chain} | prompt_second | llm | StrOutputParser()

#invoking the chains of calls passing the worth to chain 1 parameter
print(chain_second.invoke({"adjectective" : "well-known"}))

Perché usare catene sequenziali?

Unisce varie catene usando l’output di una catena come enter per la successiva.
Opera eseguendo una serie di catene
Creazione di un flusso senza soluzione di continuità

Passaggio 5: aggiunta di memoria (esempio di chatbot)

Vuoi che il tuo chatbot ricordi le conversazioni passate? La memoria di Langchain aiuta!

from langchain.chains import ConversationChain
from langchain.reminiscence import ConversationBufferMemory
from langchain_openai import ChatOpenAI

# Initialize mannequin with reminiscence
llm = ChatOpenAI(mannequin="gpt-3.5-turbo")
reminiscence = ConversationBufferMemory()

# Create a dialog chain
dialog = ConversationChain(llm=llm, reminiscence=reminiscence)

# Begin chatting!
print(dialog.invoke("Howdy! How is climate as we speak ?")("response"))
print(dialog.invoke("Can I am going out for biking as we speak ?")("response"))

Perché usare la memoria?

Consente all’IA di ricordare gli enter passati
Crea un chatbot più interattivo
Supporta più tipi di memoria (buffer, riepilogo, vettore, ecc.)

Qual è il prossimo?

Qui, abbiamo esplorato alcuni componenti di base di Langchain. Successivamente, esploreremo gli articoli seguenti per utilizzare la vera potenza di Langchain:

Esplorare Agenti di Langchain per il processo decisionale guidato dall’intelligenza artificiale
Attrezzo Generazione generosa del recupero (RAG) per recuperare i dati in tempo reale