Das Langchain-Framework verstehen | von Mehul Gupta | Data Science in Ihrer Tasche | September 2023

Ketten, Agenten, Retriever, Vorlagen und mehr

LLMs sind das heißeste Thema der Stadt. Doch in letzter Zeit hat sich der Schwerpunkt von LLMs auf die Verwendung dieser LLMs für reale Probleme verlagert, für die Langchain ein Framework zur Implementierung verschiedener Anwendungsfälle bereitstellt. Aber Langchain ist ein komplexes Framework mit viel Fachjargon. Heute werden wir versuchen, die verschiedenen Elemente des Langchain-Frameworks und deren Verwendung zu verstehen. Lesen Sie den vorherigen Teil für eine Anleitung zu verschiedenen Anwendungsfällen, für die Langchain verwendet werden kann

Dieser Blog enthält kurze Erklärungen zu

Modelle (LLM und ChatModel)

Eingabeaufforderungsvorlagen (verschiedene Vorlagen für Eingabeaufforderungen)

Ausgabeparser (So strukturieren Sie Ihre Ausgabe)

Ketten (Verkettung von LLMs oder anderen Tools für komplexe Probleme)

Erinnerung (um sich an frühere Gespräche zu erinnern)

Retriever (Zugriff auf externe Dokumente/Kontext mithilfe von LLMs)

Agenten (um eine Abfolge von Aktionen auszuführen, flexibler und vielfältiger als Ketten)

Rückrufe (Protokollierung von Ereignissen)

Codes und Beispiele sowie Video-Tutorials

Lasst uns loslegen

Langchain bietet zwei Arten von Modellen

• LLMs: Solche Modelle ähneln den allgemeinen LLM-Modellen, die für jeden Zweck verwendet werden können. Die Eingabeaufforderung ist ein String/eine String-Vorlage, während Sie mit ChatGPT interagieren

from langchain.llms import OpenAI
llm = OpenAI()
llm("Explain how AI wil change the world")

• ChatModels: Unter der Haube nutzen diese Modelle LLMs, sind spezifisch für Chatbots und bestehen aus drei Hauptkomponenten

HumanMessage: Die vom Benutzer gegebene Eingabeaufforderung

AIMessage: Die vom LLM gegebene Antwort

SystemMessage: Es handelt sich um einen Kontext, den wir über seine Rolle an das Chatmodel übergeben können.

from langchain.chat_models import ChatOpenAI
from langchain.schema import HumanMessage,SystemMessage
messages = [SystemMessage(
content="You are a Grammar Teacher who responds Yes for correct Grammar input"),
HumanMessage(content="I love, programming.")]
chat = ChatOpenAI()
chat(messages)

Wie Sie sehen können, fungiert dieses Chat-Modell jetzt als Grammatiklehrer für jede Eingabeaufforderung. Sie müssen nicht die gesamte Eingabeaufforderung erneut schreiben, wenn der Anwendungsfall derselbe ist.

Wie kann diese Eingabeaufforderung anpassbarer gestaltet werden?

Wie Sie sicher schon erraten haben, handelt es sich hierbei um vordefinierte Vorlagen für Eingabeaufforderungen für ein LLM, sodass Sie keine Eingabeaufforderungen von Grund auf neu schreiben müssen. Es gibt jedoch unterschiedliche Arten dieser Eingabeaufforderungen

PromptTemplate: Dies wird verwendet, um eine Eingabeaufforderung aus einer Zeichenfolgeneingabe zu erstellen. Dies kann als Basisversion von Vorlagen betrachtet werden, bei der Sie je nach Bedarf eine Variable übergeben oder einfach eine ganze Eingabeaufforderung schreiben können. Diese werden normalerweise mit den oben erläuterten LLM-Modellen verwendet.

from langchain.prompts import PromptTemplate
prompt_template = PromptTemplate.from_template(
"Write {lines} lines about {topic}"
)
prompt_template.format(lines="5", topic="India")
OR
prompt_template = PromptTemplate.from_template(
"Write 5 lines about India"
)
prompt_template.format()

In diesem Beispiel können Sie sehen, wie wir zwei Variablen, Zeilen und Thema verwenden, wobei die Kernaufforderung gleich bleibt. Jetzt kann dies als „Essay-Generator“-App für jedes Thema fungieren, bei dem Sie die Gesamtzeilen und Themen anpassen können. Oder Sie geben einfach eine Zeichenfolgenaufforderung ohne Variablen ein. Erfahren Sie, wie PromptTemplate für mehrere Anwendungsfälle verwendet werden kann

from langchain.prompts import ChatPromptTemplate
from langchain.prompts.chat import SystemMessage, HumanMessagePromptTemplate
from langchain.chat_models import ChatOpenAI
template = ChatPromptTemplate.from_messages(
[
SystemMessage(
content=("You are a python coder AI that helps user with bugs 
and writing programs")),
HumanMessagePromptTemplate.from_template("{text}"),
]
)
llm = ChatOpenAI()
llm(template.format_messages(text='Check whether a number is prime or not'))

from langchain.output_parsers import CommaSeparatedListOutputParser
from langchain.prompts import PromptTemplate
from langchain.llms import OpenAI
output_parser = CommaSeparatedListOutputParser()
format_instructions = output_parser.get_format_instructions()
prompt = PromptTemplate(
template="List down 5 items that start with letter {alphabet}",
input_variables=["alphabet"],
partial_variables={"format_instructions": format_instructions}
)
model = OpenAI(temperature=0)
output = model(prompt.format(alphabet="j"))
output_parser.parse(output)

from langchain.utilities import SQLDatabase
from langchain.llms import OpenAI
from langchain_experimental.sql import SQLDatabaseChain
db = SQLDatabase.from_uri("sqlite:///Chinook.db")
llm = OpenAI(temperature=0, verbose=True)
db_chain = SQLDatabaseChain.from_llm(llm, db, verbose=True)
db_chain.run("How many employees have joined the organization last year?")

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 = """You are a nice chatbot having a conversation with a human.
Previous conversation:
{chat_history}
New human question: {question}
Response:"""
prompt = PromptTemplate.from_template(template)
memory = ConversationBufferMemory(memory_key="chat_history")
conversation = LLMChain(
llm=llm,
prompt=prompt,
verbose=True,
memory=memory
)

from langchain.chains import RetrievalQA
from langchain.document_loaders import TextLoader
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.llms import OpenAI
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores import Chroma
#Document loader
loader = TextLoader("abc.txt")
documents = loader.load()
#Document Transoformer
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(documents)
#Embedding model
embeddings = OpenAIEmbeddings()
#Vector DB to store embeddings
docsearch = Chroma.from_documents(texts, embeddings)
#Retriever being used using parameter retriever
qa = RetrievalQA.from_chain_type(llm=OpenAI(), chain_type="stuff", retriever=docsearch.as_retriever())
query = "What this document about? Summarize it in a paragraph"
qa.run(query)

#!pip install langchain openai google-search-results
from langchain.agents import Tool
from langchain.agents import AgentType
from langchain.memory import ConversationBufferMemory
from langchain.llms import OpenAI
from langchain.utilities import SerpAPIWrapper
from langchain.agents import initialize_agent
#You need to get serp_api and openai_api for this.
search = SerpAPIWrapper(serpapi_api_key=serp_api)
llm=OpenAI(openai_api_key=api_key)
tools = [
Tool(
name = "Current Search",
func=search.run,
description="useful for when you need to answer questions about current events or the current state of the world"
),]
agent_chain = initialize_agent(tools, llm, agent=AgentType.CONVERSATIONAL_REACT_DESCRIPTION)
agent_chain.run("Explain what happend in G20 meeting, 2023 that happened in Delhi?")

from langchain.callbacks import StdOutCallbackHandler
from langchain.chains import LLMChain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
handler = StdOutCallbackHandler()
llm = OpenAI()
prompt = PromptTemplate.from_template("Write {number} lines about {animal} ")
# Constructor callback: First, let's explicitly set the StdOutCallbackHandler when initializing our chain
chain = LLMChain(llm=llm, prompt=prompt, callbacks=[handler])
chain.run(number=2,animal='tiger')