langchain开发框架实践（一）

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI

# 定义提示模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a world-class technical documentation writer."),
    ("user", "{input}")
])

# 填充模型名
llm = ChatOpenAI(
    model_name='qwen1.5-32b-chat-int4',
    openai_api_base='http://20.20.136.251:8001/v1',
    openai_api_key='q7r8s9t0-u1v2-w3x4-y5z6-a7b8c9d0e1f2'
)

# 定义输出解析器
output_parser = StrOutputParser()

# 创建链条
chain = prompt | llm | output_parser

# 生成 prompt 的值
prompt_value = prompt.invoke({"input": "how can langsmith help with testing?"})
print(prompt_value)

# 通过链条获取模型的响应
response = chain.invoke(prompt_value)

# 打印模型响应
print(response)

from langchain.prompts import PromptTemplate
prompt_template = PromptTemplate.from_template(
    "Tell me a {adjective} joke about {content}."
)
prompt_template.format(adjective="funny", content="chickens")
# Tell me a funny joke about chickens.

from langchain_core.prompts import ChatPromptTemplate
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}"),
    ]
)
messages = chat_template.format_messages(name="Bob", user_input="What is your name?")
# [SystemMessage(content="You are a helpful assistant that re-writes the user's text to sound more upbeat."), HumanMessage(content="I don't like eating tasty things")]

# 1. 定义example variables list
examples = [
    {"input": "happy", "output": "sad"},
    {"input": "tall", "output": "short"},
    {"input": "energetic", "output": "lethargic"},
    {"input": "sunny", "output": "gloomy"},
    {"input": "windy", "output": "calm"},
]
# 2. 为examples定义example_prompt模板
example_prompt = PromptTemplate(
    input_variables=["input", "output"],
    template="Input: {input}\nOutput: {output}",
)
# 3. 将example variables list和example_prompt输入到example_selector中
example_selector = LengthBasedExampleSelector(
    examples=examples,
    example_prompt=example_prompt,
    max_length=25)
# 4. 定义few_shot_prompt模板（prefix + examples + suffix）
dynamic_prompt = FewShotPromptTemplate(
    example_selector=example_selector,
    example_prompt=example_prompt,
    prefix="Give the antonym of every input",  # 前缀，定义task
    suffix="Input: {adjective}\nOutput:",  # 后缀
    input_variables=["adjective"],  # 后缀参数变量
)
print(dynamic_prompt.invoke({"adjective": "funny"}).text)

Give the antonym of every input

Input: happy
Output: sad

Input: tall
Output: short

Input: energetic
Output: lethargic

Input: sunny
Output: gloomy

Input: windy
Output: calm

Input: funny
Output:

from langchain.llms import vllm  # langchain v 0.1.0
from langchain_community.llms import vllm  # langchain v 0.2.0
llm = vllm.VLLM(model="/data1/huggingface/LLM/Mistral-7B-Instruct-v0.2")
llm.invoke({"input": "how can langsmith help with testing?"})

from langchain_openai import ChatOpenAI
chat = ChatOpenAI(openai_api_key="...")
from langchain_core.messages import HumanMessage, SystemMessage
messages = [
    SystemMessage(content="You're a helpful assistant"),
    HumanMessage(content="What is the purpose of model regularization?"),
]
chat.invoke(messages)

from typing import List
from langchain_openai import ChatOpenAI
from langchain.output_parsers import PydanticOutputParser
from langchain.prompts import PromptTemplate
from langchain_core.pydantic_v1 import BaseModel, Field, validator

# Define your desired data structure.
class Joke(BaseModel):
    setup: str = Field(description="question to set up a joke")  # 笑话设置的部分
    punchline: str = Field(description="answer to resolve the joke")  # 笑话的冷笑话部分

    # 对笑话进行逻辑验证，保证setup的部分以？结尾
    @validator("setup")
    def question_ends_with_question_mark(cls, field):
        if field[-1] != "?":
            raise ValueError("Badly formed question!")
        return field

# 初始化ChatOpenAI实例
llm = ChatOpenAI(
    model_name='qwen1.5-32b-chat-int4',  # 替换为你使用的模型名称
    openai_api_base='http://20.20.136.251:8001/v1',  # 替换为你的API base URL
    openai_api_key='q7r8s9t0-u1v2-w3x4-y5z6-a7b8c9d0e1f2'  # 替换为你的API密钥
)

# And a query intented to prompt a language model to populate the data structure.
joke_query = "Tell me a joke."

# Set up a parser + inject instructions into the prompt template.
parser = PydanticOutputParser(pydantic_object=Joke)

prompt = PromptTemplate(
    template="Answer the user query.\n{format_instructions}\n{query}\n",
    input_variables=["query"],
    partial_variables={"format_instructions": parser.get_format_instructions()},
)

print(prompt)

chain = prompt | llm | parser

print(chain.invoke({"query": joke_query}))

Joke(setup="Why don't scientists trust atoms?", punchline='Because they make up everything!')

from typing import List

from langchain.prompts import PromptTemplate
from langchain_core.output_parsers import JsonOutputParser
from langchain_core.pydantic_v1 import BaseModel, Field
from langchain_openai import ChatOpenAI
model = ChatOpenAI(temperature=0)
# Define your desired data structure.
class Joke(BaseModel):
    setup: str = Field(description="question to set up a joke")
    punchline: str = Field(description="answer to resolve the joke")
    # And a query intented to prompt a language model to populate the data structure.

joke_query = "Tell me a joke."

# Set up a parser + inject instructions into the prompt template.
parser = JsonOutputParser(pydantic_object=Joke)

prompt = PromptTemplate(
    template="Answer the user query.\n{format_instructions}\n{query}\n",
    input_variables=["query"],
    partial_variables={"format_instructions": parser.get_format_instructions()},
)

chain = prompt | model | parser

chain.invoke({"query": joke_query})

{'setup': "Why don't scientists trust atoms?",
 'punchline': 'Because they make up everything!'}

from langchain.output_parsers import ResponseSchema, StructuredOutputParser
from langchain_core.prompts import PromptTemplate, load_prompt
from langchain_openai import ChatOpenAI

# 初始化ChatOpenAI实例
llm = ChatOpenAI(
    model_name='qwen1.5-32b-chat-int4',  # 替换为你使用的模型名称
    openai_api_base='http://20.20.136.251:8001/v1',  # 替换为你的API base URL
    openai_api_key='q7r8s9t0-u1v2-w3x4-y5z6-a7b8c9d0e1f2'  # 替换为你的API密钥
)

# 响应模式指导LLM的输出解析格式，传入StructuredOutputParser
response_schemas = [
    ResponseSchema(name="answer", description="answer to the user's question"),
    ResponseSchema(name="source", description="source used to answer the user's question, should be a website."),
]
output_parser = StructuredOutputParser.from_response_schemas(response_schemas)
format_instructions = output_parser.get_format_instructions()
print(format_instructions)

prompt = PromptTemplate(
    template="answer the users question as best as possible.\n{format_instructions}\n{question}",
    input_variables=["question"],
    partial_variables={"format_instructions": format_instructions},
)
print(prompt)

chain = prompt | llm | output_parser
print(chain.invoke({"question": "what's the capital of france?"}))

{'answer': 'The capital of France is Paris.',
 'source': 'https://en.wikipedia.org/wiki/Paris'}