class BaseCallbackHandler:
    """可用于处理来自langchain的回调的基本回调处理程序。"""
 
    def on_llm_start(
        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
    ) -> Any:
        """LLM开始运行时运行。"""
 
    def on_chat_model_start(
        self, serialized: Dict[str, Any], messages: List[List[BaseMessage]], **kwargs: Any
    ) -> Any:
        """Chat Model开始运行时运行。"""
 
    def on_llm_new_token(self, token: str, **kwargs: Any) -> Any:
        """在新LLM令牌上运行。仅在启用流式处理时可用。"""
 
    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> Any:
        """LLM结束运行时运行。"""
 
    def on_llm_error(
        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
    ) -> Any:
        """处理LLM错误时运行。"""
 
    def on_chain_start(
        self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
    ) -> Any:
        """链开始运行时运行。"""
 
    def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> Any:
        """链结束运行时运行。"""
 
    def on_chain_error(
        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
    ) -> Any:
        """处理链错误时运行。"""
 
    def on_tool_start(
        self, serialized: Dict[str, Any], input_str: str, **kwargs: Any
    ) -> Any:
        """工具开始运行时运行。"""
 
    def on_tool_end(self, output: Any, **kwargs: Any) -> Any:
        """工具结束运行时运行。"""
 
    def on_tool_error(
        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
    ) -> Any:
        """处理工具错误时运行。"""
 
    def on_text(self, text: str, **kwargs: Any) -> Any:
        """在任意文本上运行。"""
 
    def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
        """处理代理动作时运行。"""
 
    def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> Any:
        """在代理结束时运行。"""

from langchain_core.callbacks import StdOutCallbackHandler
from langchain.chains import LLMChain
from langchain_openai import OpenAI
from langchain_core.prompts import PromptTemplate
 
handler = StdOutCallbackHandler()
llm = OpenAI()
prompt = PromptTemplate.from_template("1 + {number} = ")
 
# 构造回调：首先，在初始化链时明确设置StdOutCallbackHandler
chain = LLMChain(llm=llm, prompt=prompt, callbacks=[handler])
chain.invoke({"number":2})
 
# 使用verbose标志：然后，让我们使用`verbose`标志来达到相同的结果
chain = LLMChain(llm=llm, prompt=prompt, verbose=True)
chain.invoke({"number":2})
 
# 请求回调：最后，让我们使用请求`callbacks`来达到相同的结果
chain = LLMChain(llm=llm, prompt=prompt)
chain.invoke({"number":2}, {"callbacks":[handler]})
 

> 进入新的LLMChain链...
格式化后的提示:
1 + 2 = 

> 完成链。


> 进入新的LLMChain链...
格式化后的提示:
1 + 2 = 

> 完成链。


> 进入新的LLMChain链...
格式化后的提示:
1 + 2 = 

> 完成链。

handler = StdOutCallbackHandler()
llm = OpenAI()
prompt = PromptTemplate.from_template("1 + {number} = ")
 
config = {
    'callbacks' : [handler]
}
 
chain = prompt | chain
chain.invoke({"number":2}, config=config)

from langchain_community.document_loaders import TextLoader
 
loader = TextLoader("./index.md")
loader.load()

[
    Document(page_content='---\nsidebar_position: 0\n---\n# Document loaders\n\nUse document loaders to load data from a source as `Document`\'s. A `Document` is a piece of text\nand associated metadata. For example, there are document loaders for loading a simple `.txt` file, for loading the text\ncontents of any web page, or even for loading a transcript of a YouTube video.\n\nEvery document loader exposes two methods:\n1. "Load": load documents from the configured source\n2. "Load and split": load documents from the configured source and split them using the passed in text splitter\n\nThey optionally implement:\n\n3. "Lazy load": load documents into memory lazily\n', metadata={'source': '../modules/data_connection/document_loaders/index.md'})
]

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
 
template = """仅基于以下上下文回答问题：
 
{context}
 
问题：{question}
"""
prompt = ChatPromptTemplate.from_template(template)
model = ChatOpenAI()
 
 
def format_docs(docs):
    return "\n\n".join([d.page_content for d in docs])
 
 
chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | model
    | StrOutputParser()
)
 
chain.invoke("总统对技术说了什么？")
 

from langchain_core.retrievers import BaseRetriever
from langchain_core.callbacks import CallbackManagerForRetrieverRun
from langchain_core.documents import Document
from typing import List
 
 
class CustomRetriever(BaseRetriever):
    
    def _get_relevant_documents(
        self, query: str, *, run_manager: CallbackManagerForRetrieverRun
    ) -> List[Document]:
        return [Document(page_content=query)]
 
retriever = CustomRetriever()
 
retriever.get_relevant_documents("bar")
```# 文本嵌入模型
 
:::🗒️
请前往[Integrations](/docs/integrations/text_embedding/)查看与文本嵌入模型提供商内置集成的文档。
:::
 
Embeddings类是一个设计用于与文本嵌入模型进行接口的类。有许多嵌入模型提供商（OpenAI，Cohere，Hugging Face等）-该类旨在为所有这些提供商提供一个标准接口。
 
嵌入模型会创建文本的向量表示。这很有用，因为这意味着我们可以在向量空间中思考文本，并执行诸如语义搜索之类的操作，在其中查找在向量空间中最相似的文本片段。
 
LangChain中的基本Embeddings类提供了两种方法：用于嵌入文档和用于嵌入查询。前者以多个文本作为输入，而后者以单个文本作为输入。之所以将它们作为两个单独的方法，是因为一些嵌入提供商针对文档（用于搜索）与查询（搜索查询本身）具有不同的嵌入方法。
 
## 入门
 
### 设置
 
import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';
 
<Tabs>
  <TabItem value="openai" label="OpenAI" default>
首先，我们需要安装OpenAI合作伙伴包：
 
```bash
pip install langchain-openai

export OPENAI_API_KEY="..."

from langchain_openai import OpenAIEmbeddings
 
embeddings_model = OpenAIEmbeddings(api_key="...")

from langchain_openai import OpenAIEmbeddings
 
embeddings_model = OpenAIEmbeddings()

pip install langchain-cohere

export COHERE_API_KEY="..."

from langchain_cohere import CohereEmbeddings
 
embeddings_model = CohereEmbeddings(cohere_api_key="...")

from langchain_cohere import CohereEmbeddings
 
embeddings_model = CohereEmbeddings()

embeddings = embeddings_model.embed_documents(
    [
        "嗨！",
        "哦，你好！",
        "你叫什么名字？",
        "我的朋友叫我World",
        "你好，世界！"
    ]
)
len(embeddings), len(embeddings[0])

(5, 1536)

embedded_query = embeddings_model.embed_query("对话中提到的名字是什么？")
embedded_query[:5]

[0.0053587136790156364,
 -0.0004999046213924885,
 0.038883671164512634,
 -0.003001077566295862,
 -0.00900818221271038]

pip install chromadb

import os
import getpass
 
os.environ['OPENAI_API_KEY'] = getpass.getpass('OpenAI API Key:')

from langchain_community.document_loaders import TextLoader
from langchain_openai import OpenAIEmbeddings
from langchain_text_splitters import CharacterTextSplitter
from langchain_community.vectorstores import Chroma
 
# 加载文档，将其分成块，对每个块进行嵌入，然后将其加载到向量存储中。
raw_documents = TextLoader('../../../state_of_the_union.txt').load()
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0）
documents = text_splitter.split_documents(raw_documents)
db = Chroma.from_documents(documents, OpenAIEmbeddings())

pip install faiss-cpu

import os
import getpass
 
os.environ['OPENAI_API_KEY'] = getpass.getpass('OpenAI API Key:')

from langchain_community.document_loaders import TextLoader
from langchain_openai import OpenAIEmbeddings
from langchain_text_splitters import CharacterTextSplitter
from langchain_community.vectorstores import FAISS
 
# 加载文档，将其分成块，对每个块进行嵌入，然后将其加载到向量存储中。
raw_documents = TextLoader('../../../state_of_the_union.txt').load()
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
documents = text_splitter.split_documents(raw_documents)
db = FAISS.from_documents(documents, OpenAIEmbeddings())

pip install lancedb

import os
import getpass
 
os.environ['OPENAI_API_KEY'] = getpass.getpass('OpenAI API Key:')

from langchain_community.document_loaders import TextLoader
from langchain_openai import OpenAIEmbeddings
from langchain_text_splitters import CharacterTextSplitter
from langchain_community.vectorstores import LanceDB
 
import lancedb
 
db = lancedb.connect("/tmp/lancedb")
table = db.create_table(
    "my_table",
    data=[
        {
            "vector": embeddings.embed_query("Hello World"),
            "text": "Hello World",
            "id": "1",
        }
    ],
    mode="overwrite",
)
 
# 加载文档，将其分成块，对每个块进行嵌入，然后将其加载到向量存储中。
raw_documents = TextLoader('../../../state_of_the_union.txt').load()
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
documents = text_splitter.split_documents(raw_documents)
db = LanceDB.from_documents(documents, OpenAIEmbeddings())

query = "总统对Ketanji Brown Jackson说了什么"
docs = db.similarity_search(query)
print(docs[0].page_content)

    今晚。我呼吁参议院：通过“自由投票法案”。通过“约翰·刘易斯投票权法案”。并且在您这样做的时候通过“披露法案”以便美国人知道是谁在资助我们的选举。

    今晚，我想向一个一直致力于为这个国家服务的人致敬：司法部长斯蒂芬·布雷耶-一位陆军退伍军人、宪法学者和美国最高法院即将退休的法官。布雷耶法官，感谢您的服务。

    总统的一个最严肃的宪法责任就是任命一个人担任美国最高法院的法官。

    而我在4天前也做了，我提名了巡回上诉法院法官Ketanji Brown Jackson。她是我国顶尖的法律精英，将继续布雷耶法官卓越的遗产。

embedding_vector = OpenAIEmbeddings().embed_query(query)
docs = db.similarity_search_by_vector(embedding_vector)
print(docs[0].page_content)

    今晚。我呼吁参议院：通过“自由投票法案”。通过“约翰·刘易斯投票权法案”。并且在您这样做的时候通过“披露法案”以便美国人知道是谁在资助我们的选举。

    今晚，我想向一个一直致力于为这个国家服务的人致敬：司法部长斯蒂芬·布雷耶-一位陆军退伍军人、宪法学者和美国最高法院即将退休的法官。布雷耶法官，感谢您的服务。

    总统的一个最严肃的宪法责任就是任命一个人担任美国最高法院的法官。

    而我在4天前也做了，我提名了巡回上诉法院法官Ketanji Brown Jackson。她是我国顶尖的法律精英，将继续布雷耶法官卓越的遗产。

pip install qdrant-client

from langchain_community.vectorstores import Qdrant

db = await Qdrant.afrom_documents(documents, embeddings, "http://localhost:6333")

query = "总统对Ketanji Brown Jackson说了什么"
docs = await db.asimilarity_search(query)
print(docs[0].page_content)

    今晚。我呼吁参议院：通过“自由投票法案”。通过“约翰·刘易斯投票权法案”。并且在您这样做的时候通过“披露法案”以便美国人知道是谁在资助我们的选举。

    今晚，我想向一个一直致力于为这个国家服务的人致敬：司法部长斯蒂芬·布雷耶-一位陆军退伍军人、宪法学者和美国最高法院即将退休的法官。布雷耶法官，感谢您的服务。

    总统的一个最严肃的宪法责任就是任命一个人担任美国最高法院的法官。

    而我在4天前也做了，我提名了巡回上诉法院法官Ketanji Brown Jackson。她是我国顶尖的法律精英，将继续布雷耶法官卓越的遗产。

embedding_vector = embeddings.embed_query(query)
docs = await db.asimilarity_search_by_vector(embedding_vector)

query = "总统对Ketanji Brown Jackson说了什么"
found_docs = await qdrant.amax_marginal_relevance_search(query, k=2, fetch_k=10)
for i, doc in enumerate(found_docs):
    print(f"{i + 1}.", doc.page_content, "\n")

1. 今晚。我呼吁参议院：通过“自由投票法案”。通过“约翰·刘易斯投票权法案”。并且在您这样做的时候通过“披露法案”以便美国人知道是谁在资助我们的选举。

今晚，我想向一个一直致力于为这个国家服务的人致敬：司法部长斯蒂芬·布雷耶-一位陆军退伍军人、宪法学者和美国最高法院即将退休的法官。布雷耶法官，感谢您的服务。

总统的一个最严肃的宪法责任就是任命一个人担任美国最高法院的法官。

而我在4天前也做了，我提名了巡回上诉法院法官Ketanji Brown Jackson。她是我国顶尖的法律精英，将继续布雷耶法官卓越的遗产。

2. 我们不能改变我们之间的分歧。但我们可以改变我们如何共同前进-在COVID-19和必须共同面对的其他问题上。

不久前，我在纽约市警察局让后在警官Wilbert Mora和他的搭档警官Jason Rivera的葬礼后几天造访了。他们在响应一个911电话时，一个男子用一把偷来的枪射杀了他们。

莫拉警官27岁。

里维拉警官22岁。

两位多米尼加裔美国人，他们在同一条街道长大，后来选择作为警察巡逻。

我和他们的家人交谈，并告诉他们，我们永远要对他们的牺牲感激，我们将继续履行他们恢复每个社区应得的信任和安全使命。

我一直在关注这些问题很久了。
我知道什么管用：投资于犯罪预防和社区警察官员，他们会巡逻，会了解社区，会恢复信任和安全。

from langchain.memory import ChatMessageHistory
 
history = ChatMessageHistory()
 
history.add_user_message("嗨！")
 
history.add_ai_message("最近怎么样？")

history.messages

    [HumanMessage(content='嗨！', additional_kwargs={}),
     AIMessage(content='最近怎么样？', additional_kwargs={})]

from langchain.memory import ConversationBufferMemory
 
memory = ConversationBufferMemory()
memory.chat_memory.add_user_message("hi!")
memory.chat_memory.add_ai_message("what's up?")

memory.load_memory_variables({})

    {'history': "Human: hi!\nAI: what's up?"}

memory = ConversationBufferMemory(memory_key="chat_history")
memory.chat_memory.add_user_message("hi!")
memory.chat_memory.add_ai_message("what's up?")

    {'chat_history': "Human: hi!\nAI: what's up?"}

memory = ConversationBufferMemory(return_messages=True)
memory.chat_memory.add_user_message("hi!")
memory.chat_memory.add_ai_message("what's up?")

    {'history': [HumanMessage(content='hi!', additional_kwargs={}, example=False),
  AIMessage(content='what's up?', additional_kwargs={}, example=False)]}

from langchain_openai import OpenAI
from langchain_core.prompts import PromptTemplate
from langchain.chains import LLMChain
from langchain.memory import ConversationBufferMemory
 
 
llm = OpenAI(temperature=0)
# 注意“chat_history”出现在提示模板中
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_key`
memory = ConversationBufferMemory(memory_key="chat_history")
conversation = LLMChain(
    llm=llm,
    prompt=prompt,
    verbose=True,
    memory=memory
)

# 注意我们只传入`question`变量 - `chat_history`将由记忆填充
conversation({"question": "hi"})

from langchain_openai import ChatOpenAI
from langchain.prompts import (
    ChatPromptTemplate,
    MessagesPlaceholder,
    SystemMessagePromptTemplate,
    HumanMessagePromptTemplate,
)
from langchain.chains import LLMChain
from langchain.memory import ConversationBufferMemory
 
 
llm = ChatOpenAI()
prompt = ChatPromptTemplate(
    messages=[
        SystemMessagePromptTemplate.from_template(
            "You are a nice chatbot having a conversation with a human."
        ),
        # 这里的`variable_name`必须与记忆对齐
        MessagesPlaceholder(variable_name="chat_history"),
        HumanMessagePromptTemplate.from_template("{question}")
    ]
)
# 注意我们`return_messages=True`以适应MessagesPlaceholder
# 注意`"chat_history"`与MessagesPlaceholder名称对齐。
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
conversation = LLMChain(
    llm=llm,
    prompt=prompt,
    verbose=True,
    memory=memory
)

# 注意我们只传入`question`变量 - `chat_history`将由记忆填充
conversation({"question": "hi"})

pip install langchain-openai

export OPENAI_API_KEY="..."

from langchain_openai import ChatOpenAI
from langchain_openai import OpenAI
 
llm = OpenAI()
chat_model = ChatOpenAI(model="gpt-3.5-turbo-0125")

from langchain_openai import ChatOpenAI
llm = ChatOpenAI(api_key="...")

from langchain_core.messages import HumanMessage
 
text = "What would be a good company name for a company that makes colorful socks?"
messages = [HumanMessage(content=text)]
 
llm.invoke(text)
# >> Feetful of Fun
 
chat_model.invoke(messages)
# >> AIMessage(content="Socks O'Color")

from langchain_community.llms import Ollama
from langchain_community.chat_models import ChatOllama
 
llm = Ollama(model="llama2")
chat_model = ChatOllama()

from langchain_core.messages import HumanMessage
 
text = "What would be a good company name for a company that makes colorful socks?"
messages = [HumanMessage(content=text)]
 
llm.invoke(text)
# >> Feetful of Fun
 
chat_model.invoke(messages)
# >> AIMessage(content="Socks O'Color")

pip install langchain-anthropic

export ANTHROPIC_API_KEY="..."

from langchain_anthropic import ChatAnthropic
 
chat_model = ChatAnthropic(model="claude-3-sonnet-20240229", temperature=0.2, max_tokens=1024)

chat_model = ChatAnthropic(api_key="...")

pip install langchain-cohere

export COHERE_API_KEY="..."

from langchain_cohere import ChatCohere
 
chat_model = ChatCohere()

from langchain_cohere import ChatCohere
 
chat_model = ChatCohere(cohere_api_key="...")

from langchain.prompts import PromptTemplate
 
prompt = PromptTemplate.from_template("生成一个制作{product}的公司的产品列表。")
prompt.format(product="多彩的袜子")

生成一个制作多彩的袜子的公司的产品列表。

from langchain.prompts.chat import ChatPromptTemplate
 
template = "您是一个有帮助的助手，可以将输入语言{input_language}翻译成输出语言{output_language}。"
human_template = "{text}"
 
chat_prompt = ChatPromptTemplate.from_messages([
    ("system", template),
    ("human", human_template),
])
 
chat_prompt.format_messages(input_language="英语", output_language="法语", text="我喜欢编程。")

[
    SystemMessage(content="您是一个有帮助的助手，可以将输入语言英语翻译为输出语言法语。", additional_kwargs={}),
    HumanMessage(content="我喜欢编程。")
]

from langchain.output_parsers import CommaSeparatedListOutputParser
 
output_parser = CommaSeparatedListOutputParser()
output_parser.parse("你好，再见")
# >> ['你好', '再见']

template = "生成一个{num}个[对象]的列表。\n\n{format_instructions}"
 
chat_prompt = ChatPromptTemplate.from_template(template)
chat_prompt = chat_prompt.partial(format_instructions=output_parser.get_format_instructions())
chain = chat_prompt | chat_model | output_parser
chain.invoke({"num": 5})
# >> ['red', 'blue', 'green', 'yellow', 'orange']

class BaseExampleSelector(ABC):
    """选择提示中要包含的示例的接口。"""
 
    @abstractmethod
    def select_examples(self, input_variables: Dict[str, str]) -> List[dict]:
        """根据输入选择要使用的示例。"""
        
    @abstractmethod
    def add_example(self, example: Dict[str, str]) -> Any:
        """将新示例添加到存储。"""

examples = [
    {"input": "hi", "output": "ciao"},
    {"input": "bye", "output": "arrivaderci"},
    {"input": "soccer", "output": "calcio"},
]

from langchain_core.example_selectors.base import BaseExampleSelector
 
 
class CustomExampleSelector(BaseExampleSelector):
    def __init__(self, examples):
        self.examples = examples
 
    def add_example(self, example):
        self.examples.append(example)
 
    def select_examples(self, input_variables):
        # 这假设知道输入的一部分将是一个 'text' 键
        new_word = input_variables["input"]
        new_word_length = len(new_word)
 
        # 初始化变量以存储最佳匹配及其长度差异
        best_match = None
        smallest_diff = float("inf")
 
        # 遍历每个示例
        for example in self.examples:
            # 计算第一个示例单词的长度差异
            current_diff = abs(len(example["input"]) - new_word_length)
 
            # 如果当前示例在长度上更接近，则更新最佳匹配
            if current_diff < smallest_diff:
                smallest_diff = current_diff
                best_match = example
 
        return [best_match]

example_selector = CustomExampleSelector(examples)

example_selector.select_examples({"input": "okay"})

[{'input': 'bye', 'output': 'arrivaderci'}]

example_selector.add_example({"input": "hand", "output": "mano"})

example_selector.select_examples({"input": "okay"})

[{'input': 'hand', 'output': 'mano'}]

from langchain_core.prompts.few_shot import FewShotPromptTemplate
from langchain_core.prompts.prompt import PromptTemplate
 
example_prompt = PromptTemplate.from_template("Input: {input} -> Output: {output}")

prompt = FewShotPromptTemplate(
    example_selector=example_selector,
    example_prompt=example_prompt,
    suffix="Input: {input} -> Output:",
    prefix="将以下单词从英语翻译为意大利语:",
    input_variables=["input"],
)
 
print(prompt.format(input="word"))

from langchain_community.tools import WikipediaQueryRun
from langchain_community.utilities import WikipediaAPIWrapper

api_wrapper = WikipediaAPIWrapper(top_k_results=1, doc_content_chars_max=100)
tool = WikipediaQueryRun(api_wrapper=api_wrapper)

tool.name

tool.description

tool.args

tool.return_direct

tool.run({"query": "langchain"})

tool.run("langchain")

from langchain_core.pydantic_v1 import BaseModel, Field
 
class WikiInputs(BaseModel):
    """Wikipedia工具的输入。"""
    
    query: str = Field(
        description="在维基百科查找的查询，应为3个单词或更少"
    )

tool = WikipediaQueryRun(
    name="wiki-tool",
    description="在维基百科查找东西",
    args_schema=WikiInputs,
    api_wrapper=api_wrapper,
    return_direct=True,
)

tool.name

tool.description

tool.args

tool.return_direct

tool.run("langchain")