Erste Schritte mit LangChain

Was ist LangChain?

LangChain ist ein leistungsstarkes Framework, das Entwicklern dabei helfen soll, End-to-End-Anwendungen mithilfe von Sprachmodellen zu erstellen. Es bietet eine Reihe von Tools, Komponenten und Schnittstellen, die den Prozess der Erstellung von Anwendungen vereinfachen, die auf großen Sprachmodellen (LLM) und Chat-Modellen basieren. LangChain kann problemlos Interaktionen mit Sprachmodellen verwalten, mehrere Komponenten miteinander verknüpfen und zusätzliche Ressourcen wie APIs und Datenbanken integrieren.
Offizielles Dokument: https://python.langchain.com/en/latest/
Chinesisches Dokument: https://www.langchain.com.cn/

Wie verwende ich LangChain?

Um LangChain nutzen zu können, müssen Entwickler zunächst notwendige Komponenten und Tools importieren, wie z. B. LLMs, Chat-Modelle, Agenten, Ketten, Speicherfunktionen. Diese Komponenten ergeben zusammen eine Anwendung, die Benutzereingaben versteht, verarbeitet und darauf reagiert.

LangChain stellt verschiedene Komponenten für spezifische Anwendungsfälle bereit, wie z. B. persönlicher Assistent, Fragen und Antworten zu Dokumenten, Chatbot, Abfrage von Formulardaten, Interaktion mit API, Extrahieren, Auswerten und Zusammenfassen.

Modell von LangChain

Das LangChain-Modell ist eine Abstraktion, die die verschiedenen im Framework verwendeten Modelltypen darstellt. Modelle in LangChain sind hauptsächlich in drei Kategorien unterteilt:
1. LLM (Large Language Model): Diese Modelle verwenden Textzeichenfolgen als Eingabe und geben Textzeichenfolgen als Ausgabe zurück. Sie sind das Rückgrat vieler Sprachmodellanwendungen.
2. Chat-Modell: Das Chat-Modell wird vom Sprachmodell unterstützt, jedoch mit einer strukturierteren API. Sie nehmen eine Liste von Chat-Nachrichten als Eingabe und geben Chat-Nachrichten zurück. Dies erleichtert die Verwaltung des Gesprächsverlaufs und die Pflege des Kontexts.
3. Modelle zur Texteinbettung: Diese Modelle nehmen Text als Eingabe und geben eine Liste von Floats zurück, die die Texteinbettung darstellen. Diese Einbettungen können für Aufgaben wie das Abrufen von Dokumenten, Clustering und Ähnlichkeitsvergleiche verwendet werden.

Hauptmerkmale von LangChain

Ziel von LangChain ist es, Entwickler in sechs Hauptbereichen zu unterstützen:
1. LLMs und Eingabeaufforderungen: Mit LangChain können Eingabeaufforderungen einfach verwaltet, optimiert und eine gemeinsame Schnittstelle für alle LLMs erstellt werden. Darüber hinaus enthält es einige praktische Dienstprogramme für die Arbeit mit LLMs.
2. Kette: Dies sind Abfolgen von Aufrufen an LLM oder andere Dienstprogramme. LangChain bietet eine Standardschnittstelle für die Kette, lässt sich in verschiedene Tools integrieren und bietet eine End-to-End-Kette für gängige Anwendungen. Generierung der Datenerweiterung:
3.LangChain ermöglicht es Ketten, mit externen Datenquellen zu interagieren, um Daten für Generierungsschritte zu sammeln. Es kann beispielsweise helfen, lange Texte zusammenzufassen oder Fragen anhand einer bestimmten Datenquelle zu beantworten.
4. Agenten: Agenten ermöglichen es dem LLM, Entscheidungen über Aktionen zu treffen, diese Aktionen durchzuführen, die Ergebnisse zu überprüfen und weiterzumachen, bis die Arbeit erledigt ist. LangChain bietet eine Standardschnittstelle für Proxys, eine Vielzahl von Proxys zur Auswahl und End-to-End-Proxy-Beispiele.
5. Speicher: LangChain verfügt über eine Standardspeicherschnittstelle, die dabei hilft, den Status zwischen Ketten- oder Proxy-Aufrufen aufrechtzuerhalten. Außerdem werden eine Reihe von Speicherimplementierungen und Beispiele für Ketten oder Agenten bereitgestellt, die Speicher verwenden.
6. Bewertung: Es ist schwierig, generative Modelle mit traditionellen Metriken zu bewerten. Aus diesem Grund stellt LangChain Hinweise und Ketten bereit, die Entwicklern dabei helfen, ihre Modelle mithilfe von LLM selbst zu bewerten.

Anwendungsbeispiel

LangChain unterstützt eine Vielzahl von Anwendungsfällen, wie zum Beispiel:

针对特定文档的问答：根据给定的文档回答问题，使用这些文档中的信息来创建答案。聊天机器人：构建可以利用 LLM 的功能生成文本的聊天机器人。Agents：开发可以决定行动、采取这些行动、观察结果并继续执行直到完成的代理。

Kurzanleitung: Verwenden Sie LangChain, um eine End-to-End-Sprachmodellanwendung zu erstellen
[OPENAI_API_KEY kann auf der offiziellen Website generiert werden (das Aufrufen der Schnittstelle erfordert Geld, was billiger ist)]
Installation
Installieren Sie zunächst LangChain. Führen Sie einfach den folgenden Befehl aus:

pip install langchain

环境设置
现在，由于 LangChain 经常需要与模型提供者、数据存储、API 等集成，我们将设置我们的环境。在这个例子中，我们将使用 OpenAI 的 API，因此我们需要安装他们的 SDK：

pip install openai

接下来，让我们在终端中设置环境变量：

export OPENAI_API_KEY = "..."

或者，如果您更喜欢在 Jupyter notebook 或 Python 脚本中工作，您可以像这样设置环境变量:

import os 
os .environ[ "OPENAI_API_KEY" ] = "..."

Aufbau von Sprachmodellanwendungen: LLM

    # 导入LLM包装器。
    from langchain.llms import OpenAI
    # 初始化包装器，temperature越高结果越随机
    llm = OpenAI(temperature=0.9)
    # 进行调用
    text = "What would be a good company name for a company that makes colorful socks?"
    print(llm(text))
    #生成结果，结果是随机的 例如： Glee Socks. Rainbow Cozy SocksKaleidoscope Socks.

Eingabeaufforderungsvorlagen: Eingabeaufforderungen zur Verwaltung von LLMs

Im Allgemeinen geben wir die Eingabe nicht direkt in das Modell ein, sondern verbinden die Eingabe mit einigen anderen Sätzen, um Eingabeaufforderungen zu bilden, und geben sie an das Modell weiter.
Im vorherigen Anwendungsfall, der auf dem Namen des Produkts basiert, möchten wir beispielsweise nur „Socken“ in den eigentlichen Dienst eingeben, dann ist „Was wäre ein guter Firmenname für ein Unternehmen, das herstellt“ unsere Vorlage?

    from langchain.prompts import PromptTemplate
    prompt = PromptTemplate(
        input_variables=["product"],
        template="What is a good name for a company that makes {product}?",
    )
    print(prompt.format(product="colorful socks"))
    # 输出结果 What is a good name for a company that makes colorful socks?

Erstellen einer Sprachmodellanwendung: Chat-Modell

Ein Chat-Modell ist ebenfalls verfügbar. Hierbei handelt es sich um Varianten von Sprachmodellen, die unter der Haube ein Sprachmodell verwenden, aber über eine andere Schnittstelle verfügen. Das Chat-Modell verwendet Chat-Nachrichten als Eingabe und Ausgabe anstelle der API „Text rein, Text raus“. Die Verwendung der Chat-Modell-API ist relativ neu, daher ist jeder immer noch dabei, herauszufinden, welche Abstraktion am besten geeignet ist.

Um einen Chat abzuschließen, müssen Sie eine oder mehrere Nachrichten an das Chat-Modell übergeben. LangChain unterstützt derzeit die Typen AIMessage, HumanMessage, SystemMessage und ChatMessage. Sie werden hauptsächlich mit HumanMessage, AIMessage und SystemMessage arbeiten.

from langchain.chat_models import ChatOpenAI
from langchain.schema import (
    AIMessage,
    HumanMessage,
    SystemMessage
)

chat = ChatOpenAI(temperature=0)
chat([HumanMessage(content="Translate this sentence from English to French. I love programming.")])
#输出结果 AIMessage(content="J'aime programmer.", additional_kwargs={})

Verwenden Sie „generate“, um Vervollständigungen für Gruppen von Nachrichten zu generieren. Dies gibt ein LLMResult mit einem zusätzlichen Nachrichtenparameter zurück:

from langchain.chat_models import ChatOpenAI
from langchain.schema import (
    AIMessage,
    HumanMessage,
    SystemMessage
)
batch_messages = [
    [
        SystemMessage(content="You are a helpful assistant that translates English to Chinese."),
        HumanMessage(content="Translate this sentence from English to Chinese. I love programming.")
    ],
    [
        SystemMessage(content="You are a helpful assistant that translates English to Chinese."),
        HumanMessage(content="Translate this sentence from English to Chinese. I love artificial intelligence.")
    ],
]
result = chat.generate(batch_messages)
print(result)

result.llm_output['token_usage']

Für Chat-Modelle können Sie auch Vorlagen verwenden, indem Sie MessagePromptTemplate verwenden. Sie können ein ChatPromptTemplate aus einem oder mehreren MessagePromptTemplates erstellen. Die Methode format_prompt des ChatPromptTemplate gibt einen PromptValue zurück, den Sie in einen String oder ein Message-Objekt konvertieren können, je nachdem, ob Sie den formatierten Wert als Eingabe für das LLM- oder Chat-Modell verwenden möchten.

from langchain.chat_models import ChatOpenAI
from langchain.prompts.chat import (
    ChatPromptTemplate,
    SystemMessagePromptTemplate,
    HumanMessagePromptTemplate,
)
chat = ChatOpenAI(temperature=0)
template="You are a helpful assistant that translates {input_language} to {output_language}."
system_message_prompt = SystemMessagePromptTemplate.from_template(template)
human_template="{text}"
human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)
chat_prompt = ChatPromptTemplate.from_messages([system_message_prompt, human_message_prompt])
# get a chat completion from the formatted messages
chat(chat_prompt.format_prompt(input_language="English", output_language="Chinese", text="I love programming.").to_messages())
# -> AIMessage(content="我喜欢编程。(Wǒ xǐhuān biānchéng.)", additional_kwargs={})

Entdecken Sie die Verwendung von Speicher mit Ketten und Agenten, die mit einem Chat-Modell initialisiert wurden. Der Hauptunterschied zu Memory for LLMs besteht darin, dass wir frühere Nachrichten als eigene, eindeutige Speicherobjekte behalten können, anstatt sie in einen String zu komprimieren.

from langchain.prompts import (
    ChatPromptTemplate, 
    MessagesPlaceholder, 
    SystemMessagePromptTemplate, 
    HumanMessagePromptTemplate
)
from langchain.chains import ConversationChain
from langchain.chat_models import ChatOpenAI
from langchain.memory import ConversationBufferMemory
prompt = ChatPromptTemplate.from_messages([
    SystemMessagePromptTemplate.from_template("The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know."),
    MessagesPlaceholder(variable_name="history"),
    HumanMessagePromptTemplate.from_template("{input}")
])
llm = ChatOpenAI(temperature=0)
memory = ConversationBufferMemory(return_messages=True)
conversation = ConversationChain(memory=memory, prompt=prompt, llm=llm)
conversation.predict(input="Hi there!")
# -> 'Hello! How can I assist you today?'
conversation.predict(input="I'm doing well! Just having a conversation with an AI.")
# -> "That sounds like fun! I'm happy to chat with you. Is there anything specific you'd like to talk about?"
conversation.predict(input="Tell me about yourself.")

Vollständiger Code

import os
os .environ[ "OPENAI_API_KEY" ] = ""
from langchain.chat_models import ChatOpenAI
from langchain.schema import (
    AIMessage,
    HumanMessage,
    SystemMessage
)
chat = ChatOpenAI(temperature=0)
batch_messages = [
    [
        SystemMessage(content="You are a helpful assistant that translates English to Chinese."),
        HumanMessage(content="Translate this sentence from English to Chinese. I love programming.")
    ],
    [
        SystemMessage(content="You are a helpful assistant that translates English to Chinese."),
        HumanMessage(content="Translate this sentence from English to Chinese. I love artificial intelligence.")
    ],
]
result = chat.generate(batch_messages)
print(result)
print(result.llm_output['token_usage'])
print("********************************************************************")
from langchain.chat_models import ChatOpenAI
from langchain.chat_models import ChatOpenAI
from langchain import LLMChain
from langchain.prompts.chat import (
    ChatPromptTemplate,
    SystemMessagePromptTemplate,
    HumanMessagePromptTemplate,
)
chat = ChatOpenAI(temperature=0)
template="You are a helpful assistant that translates {input_language} to {output_language}."
system_message_prompt = SystemMessagePromptTemplate.from_template(template)
human_template="{text}"
human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)
chat_prompt = ChatPromptTemplate.from_messages([system_message_prompt, human_message_prompt])
chain = LLMChain(llm=chat, prompt=chat_prompt)
print(chain.run(input_language="English", output_language="Chinese", text="I love programming."))
print("********************************************************************")
from langchain.prompts import (
    ChatPromptTemplate, 
    MessagesPlaceholder, 
    SystemMessagePromptTemplate, 
    HumanMessagePromptTemplate
)
from langchain.chains import ConversationChain
from langchain.chat_models import ChatOpenAI
from langchain.memory import ConversationBufferMemory

prompt = ChatPromptTemplate.from_messages([
    SystemMessagePromptTemplate.from_template("The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know."),
    MessagesPlaceholder(variable_name="history"),
    HumanMessagePromptTemplate.from_template("{input}")
])
llm = ChatOpenAI(temperature=0)
memory = ConversationBufferMemory(return_messages=True)
conversation = ConversationChain(memory=memory, prompt=prompt, llm=llm)
conversation.predict(input="Hi there!")
# -> 'Hello! How can I assist you today?'
conversation.predict(input="I'm doing well! Just having a conversation with an AI.")
# -> "That sounds like fun! I'm happy to chat with you. Is there anything specific you'd like to talk about?"
print(conversation.predict(input="Tell me about yourself."))

print("aaaaaaaa")
print(sum(range(0,101)))
# # 导入LLM包装器。
from langchain.llms import OpenAI
# 初始化包装器，temperature越高结果越随机
import os
from langchain.prompts import PromptTemplate
import openai
from langchain.prompts import PromptTemplate
from langchain.llms import OpenAI
#你申请的openai的api key
os .environ[ "OPENAI_API_KEY" ] = ""
llm = OpenAI(temperature=0.9)
# 进行调用
text = "What would be a good company name for a company that makes colorful socks?"
print(llm(text))

prompt = PromptTemplate(
    input_variables=["product"],
    template="What is a good name for a company that makes {product}?",
)
print(prompt.format(product="colorful socks"))

llm = OpenAI(temperature=0.9)
prompt = PromptTemplate(
    input_variables=["product"],
    template="What is a good name for a company that makes {product}?",
)
from langchain.chains import LLMChain
chain = LLMChain(llm=llm, prompt=prompt)
chain.run("colorful socks")
def completion(prompt):
    completions = openai.Completion.create(
    engine="text-davinci-003",
    prompt=prompt,
    max_tokens=1024,
    n=1,
    stop=None,
    temperature=0.8,
    )

    message = completions.choices[0].text
    return message

print(completion("中关村科金是一家怎样的公司？"))

Informationsextraktion

Extrahieren Sie wichtige Informationen basierend auf den Eingabeinhalten

from langchain.prompts import PromptTemplate
from langchain.llms import OpenAIChat
from langchain.chains import LLMChain
import os
import openai
# #你申请的openai的api key
os.environ['OPENAI_API_KEY'] = ''
text="北京市（Beijing），简称“京”，古称燕京、北平，是中华人民共和国首都、直辖市、国家中心城市、超大城市，国务院批复确定的中国政治中心、文化中心、国际交往中心、科技创新中心， \
    中国历史文化名城和古都之一。 截至2020年，北京市下辖16个区，总面积16410.54平方千米。  2022年末，北京市常住人口2184.3万人。 \
北京市地处中国北部、华北平原北部，东与天津市毗连，其余均与河北省相邻，中心位于东经116°20′、北纬39°56′，是世界著名古都和现代化国际城市， \
    也是中国共产党中央委员会、中华人民共和国中央人民政府和中华人民共和国全国人民代表大会常务委员会所在地。\
北京市地势西北高、东南低。西部、北部和东北部三面环山，东南部是一片缓缓向渤海倾斜的平原。境内流经的主要河流有：永定河、潮白河、北运河、拒马河等，\
北京市的气候为暖温带半湿润半干旱季风气候，夏季高温多雨，冬季寒冷干燥，春、秋短促。北京被世界城市研究机构GaWC评为世界一线城市，  \
联合国报告指出北京市人类发展指数居中国城市第二位。 [4] 北京市成功举办夏奥会与冬奥会，成为全世界第一个“双奥之城”。 \
2022年，北京市实现地区生产总值41610.9亿元，按不变价格计算，比上年增长0.7%。其中，第一产业增加值111.5亿元，下降1.6%；第二产业增加值6605.1亿元，下降11.4%；第三产业增加值34894.3亿元，增长3.4%。"

 
#加载openai的llm
llm = OpenAIChat(model_name="gpt-3.5-turbo")
 
#创建模板
fact_extraction_prompt = PromptTemplate(
    input_variables=["text_input"],
    template="从下面的本文中提取关键事实。尽量使用文本中的统计数据来说明事实:\n\n {text_input}"
)
 
#定义chain
fact_extraction_chain = LLMChain(llm=llm, prompt=fact_extraction_prompt)
facts = fact_extraction_chain.run(text)
print(facts)

Ausgabeergebnis:

Fragen und Antworten zum Dokument

import os
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.text_splitter import TokenTextSplitter
from langchain.llms import OpenAI
from langchain.chains import ChatVectorDBChain
from langchain.document_loaders import DirectoryLoader
import jieba as jb
import openai
files=['xxx.txt','xxx.txt']
import time
start_time = time.time()  
for file in files:
    #读取data文件夹中的中文文档
    my_file=f"./data/{
      
      file}"
    with open(my_file,"r",encoding='utf-8') as f:  
        data = f.read()
    
    #对中文文档进行分词处理
    cut_data = " ".join([w for w in list(jb.cut(data))])
    #分词处理后的文档保存到data文件夹中的cut子文件夹中
    cut_file=f"./data/cut/cut_{
      
      file}"
    with open(cut_file, 'w') as f:   
        f.write(cut_data)
        f.close()
        

#加载文档
loader = DirectoryLoader('./data/cut',glob='**/*.txt')
docs = loader.load()
#文档切块
text_splitter = TokenTextSplitter(chunk_size=1000, chunk_overlap=0)
doc_texts = text_splitter.split_documents(docs)
#调用openai Embeddings
a=os.environ["OPENAI_API_KEY"] = ""
embeddings = OpenAIEmbeddings(openai_api_key=a)
#向量化
vectordb = Chroma.from_documents(doc_texts, embeddings, persist_directory="./data/cut")
vectordb.persist()
#创建聊天机器人对象chain
chain = ChatVectorDBChain.from_llm(OpenAI(temperature=0, model_name="gpt-3.5-turbo"), vectordb, return_source_documents=True)

def get_answer(question):
  chat_history = []
  result = chain({
    
    "question": question, "chat_history": chat_history})
  return result["answer"]
question = "xxxxxxxxxxx"
print(get_answer(question))
end_time = time.time()    # 程序结束时间
run_time = end_time - start_time    # 程序的运行时间，单位为秒
print(run_time)

Wenn die Frage und die Antwort im Dokument enthalten sind, wird das korrekte Ergebnis zurückgegeben. Wenn sie nicht im Text enthalten sind, wird eine Fehlermeldung „
Mögliche Probleme“ zurückgegeben

UnicodeEncodeError: 'gbk' codec can't encode character '\u0643' in position 58: illegal multibyte sequence

Wenn es sich um den vscode-Editor handelt, liegt möglicherweise ein Problem mit den Computereinstellungen vor. Die Lösung ist win+i > Zeit und Sprache > Formateinstellungen für Zeit- und Datumsbereich > andere Formateinstellungen für Zeit- und Datumsbereich > regionales Datum, Uhrzeit oder Nummer ändern Format > Verwaltung > Systemgebietsschema ändern


Beta-Häkchen können dieses Problem lösen, dies gilt für TXT-Text (ich habe keine anderen Dokumente ausprobiert), das Problem ist nicht unbedingt ein Codeproblem, dieses Häkchen kann sich auf andere Computeranwendungen auswirken wird nicht)

Fragen und Antworten zur Suche (wird aktualisiert)

Mögliche Probleme:

ImportError: cannot import name 'load_tools' from 'langchain.agents'
我用的是python3.7，然后将python版本升级到了3.9就解决了。