from langchain.schema import HumanMessagefrom langchain.llms import OpenAIfrom langchain.chat_models import ChatOpenAIllm = OpenAI()chat_model = ChatOpenAI()print(llm("say hi!"))print(chat_model.predict("say hi!"))

from langchain.embeddings import OpenAIEmbeddingsembeddings = OpenAIEmbeddings()text = "This is a test document."query_result = embeddings.embed_query(text)doc_result = embeddings.embed_documents([text])print(doc_result)

from langchain import PromptTemplate

template = """I want you to act as a naming consultant for new companies.What is a good name for a company that makes {product}?"""
prompt = PromptTemplate(    input_variables=["product"],    template=template,)prompt.format(product="colorful socks")# -> I want you to act as a naming consultant for new companies.# -> What is a good name for a company that makes colorful socks?

from langchain.prompts import (    ChatPromptTemplate,    PromptTemplate,    SystemMessagePromptTemplate,    AIMessagePromptTemplate,    HumanMessagePromptTemplate,)from langchain.schema import (    AIMessage,    HumanMessage,    SystemMessage)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 messagesprint(chat_prompt.format_prompt(input_language="English", output_language="French", text="I love programming.").to_messages())

from langchain.prompts.example_selector.base import BaseExampleSelectorfrom typing import Dict, Listimport numpy as np

class CustomExampleSelector(BaseExampleSelector):
    def __init__(self, examples: List[Dict[str, str]]):        self.examples = examples
    def add_example(self, example: Dict[str, str]) -> None:        """Add new example to store for a key."""        self.examples.append(example)
    def select_examples(self, input_variables: Dict[str, str]) -> List[dict]:        """Select which examples to use based on the inputs."""        return np.random.choice(self.examples, size=2, replace=False)

examples = [    {"foo": "1"},    {"foo": "2"},    {"foo": "3"}]
# Initialize example selector.example_selector = CustomExampleSelector(examples)# Select examplesprint(example_selector.select_examples({"foo": "foo"}))# -> array([{'foo': '2'}, {'foo': '3'}], dtype=object)# Add new example to the set of examplesexample_selector.add_example({"foo": "4"})print(example_selector.examples)# -> [{'foo': '1'}, {'foo': '2'}, {'foo': '3'}, {'foo': '4'}]# Select examplesprint(example_selector.select_examples({"foo": "foo"}))# -> array([{'foo': '1'}, {'foo': '4'}], dtype=object)

from langchain.prompts import PromptTemplate, ChatPromptTemplate, HumanMessagePromptTemplatefrom langchain.llms import OpenAIfrom langchain.chat_models import ChatOpenAI
from langchain.output_parsers import PydanticOutputParserfrom pydantic import BaseModel, Field, validatorfrom typing import Listmodel_name = 'text-davinci-003'temperature = 0.0model = OpenAI(model_name=model_name, temperature=temperature)

# 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")
    # You can add custom validation logic easily with Pydantic.    @validator('setup')    def question_ends_with_question_mark(cls, field):        if field[-1] != '?':            raise ValueError("Badly formed question!")        return field
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()})joke_query = "Tell me a joke."_input = prompt.format_prompt(query=joke_query)output = model(_input.to_string())print(parser.get_format_instructions())print(output)print(parser.parse(output))

import osfrom langchain.chains import RetrievalQAfrom langchain.document_loaders import TextLoaderfrom langchain.embeddings import OpenAIEmbeddingsfrom langchain.indexes import VectorstoreIndexCreatorfrom langchain.text_splitter import CharacterTextSplitterfrom langchain.vectorstores import Chromafrom langchain.llms import OpenAI
# 设置代理os.environ['HTTP_PROXY'] = 'socks5h://127.0.0.1:13659'os.environ['HTTPS_PROXY'] = 'socks5h://127.0.0.1:13659'
# 创建文本加载器loader = TextLoader('/Users/aihe/Downloads/demo.txt', encoding='utf8')
# 加载文档documents = loader.load()
# 文本分块text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)texts = text_splitter.split_documents(documents)
# 计算嵌入向量embeddings = OpenAIEmbeddings()
# 创建向量库db = Chroma.from_documents(texts, embeddings)
# 将向量库转换为检索器retriever = db.as_retriever()
# 创建检索问答系统qa = RetrievalQA.from_chain_type(llm=OpenAI(), chain_type="stuff", retriever=retriever)
# 运行问题答案检索query = "如何申请租户?"print(qa.run(query))
print(qa.run("能否说明下你可以提供的功能？"))

from langchain import ConversationChain, OpenAIfrom langchain.memory import ConversationBufferMemory
memory = ConversationBufferMemory()memory.chat_memory.add_user_message("你好!")memory.chat_memory.add_ai_message("你好吗?")llm = OpenAI(temperature=0)chain = ConversationChain(llm=llm,                          verbose=True,                          memory=memory)chain.predict(input="最近怎么样!")print(chain.predict(input="感觉很不错，刚和AI做了场对话."))

# 引入所需模块和类from langchain.chains import LLMChainfrom langchain.chat_models import ChatOpenAIfrom langchain import PromptTemplatefrom langchain.prompts.chat import (    ChatPromptTemplate,  # 引入对话模板类    HumanMessagePromptTemplate,  # 引入人类消息模板类)
# 创建人类消息模板类human_message_prompt = HumanMessagePromptTemplate(        prompt=PromptTemplate(            template="给我一个制作{product}的好公司名字?",  # 输入模板，其中product为占位符            input_variables=["product"],  # 指定输入变量为product        )    )
# 创建对话模板类chat_prompt_template = ChatPromptTemplate.from_messages([human_message_prompt])
# 创建OpenAI聊天模型对象chat = ChatOpenAI(temperature=0.9)
# 创建LLMChain对象，将聊天模型和对话模板传入chain = LLMChain(llm=chat, prompt=chat_prompt_template)
# 运行LLMChain对象，并输出结果print(chain.run("袜子"))

# 引入所需模块和类from langchain.agents import load_tools  # 引入加载工具函数from langchain.agents import initialize_agent  # 引入初始化代理函数from langchain.agents import AgentType  # 引入代理类型类from langchain.llms import OpenAI  # 引入OpenAI语言模型类import os  # 引入os模块
# 创建OpenAI语言模型对象，设定temperature为0，即关闭随机性llm = OpenAI(temperature=0)
# 加载所需工具，包括serpapi和llm-mathtools = load_tools(["serpapi", "llm-math"], llm=llm)
# 初始化代理对象，设定代理类型为ZERO_SHOT_REACT_DESCRIPTION，输出详细信息agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)
# 运行代理对象，向其提问特朗普的年龄和年龄除以2的结果agent.run("特朗普今年多少岁? 他的年龄除以2是多少?")

initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)

import base64import jsonimport osfrom io import BytesIO
import requestsfrom PIL import Imagefrom pydantic import BaseModel, Field
from langchain.agents import AgentType, initialize_agent, load_toolsfrom langchain.chat_models import ChatOpenAIfrom langchain.llms import OpenAIfrom langchain.tools import BaseTool, StructuredTool, Tool, toolfrom langchain import LLMMathChain, SerpAPIWrapper

def generate_image(prompt: str) -> str:    """    根据提示词生成对应的图片
    Args:        prompt (str): 英文提示词
    Returns:        str: 图片的路径    """    url = "http://127.0.0.1:7860/sdapi/v1/txt2img"    headers = {        "accept": "application/json",        "Content-Type": "application/json"    }    data = {        "prompt": prompt,        "negative_prompt": "(worst quality:2), (low quality:2),disfigured, ugly, old, wrong finger",        "steps": 20,        "sampler_index": "Euler a",        "sd_model_checkpoint": "cheeseDaddys_35.safetensors [98084dd1db]",        # "sd_model_checkpoint": "anything-v3-fp16-pruned.safetensors [d1facd9a2b]",        "batch_size": 1,        "restore_faces": True    }
    response = requests.post(url, headers=headers, data=json.dumps(data))
    if response.status_code == 200:        response_data = response.json()        images = response_data['images']
        for index, image_data in enumerate(images):            img_data = base64.b64decode(image_data)            img = Image.open(BytesIO(img_data))            file_name = f"image_{index}.png"            file_path = os.path.join(os.getcwd(), file_name)            img.save(file_path)            print(f"Generated image saved at {file_path}")            return file_path    else:        print(f"Request failed with status code {response.status_code}")

def random_poem(arg: str) -> str:    """    随机返回中文的诗词
    Returns:        str: 随机的中文诗词    """    llm = OpenAI(temperature=0.9)    text = """        能否帮我从中国的诗词数据库中随机挑选一首诗给我，希望是有风景，有画面的诗：        比如：山重水复疑无路，柳暗花明又一村。    """    return llm(text)

def prompt_generate(idea: str) -> str:    """    生成图片需要对应的英文提示词
    Args:        idea (str): 中文提示词
    Returns:        str: 英文提示词    """    llm = OpenAI(temperature=0, max_tokens=2048)    res = llm(f"""    Stable Diffusion is an AI art generation model similar to DALLE-2.    Below is a list of prompts that can be used to generate images with Stable Diffusion:
    - portait of a homer simpson archer shooting arrow at forest monster, front game card, drark, marvel comics, dark, intricate, highly detailed, smooth, artstation, digital illustration by ruan jia and mandy jurgens and artgerm and wayne barlowe and greg rutkowski and zdislav beksinski    - pirate, concept art, deep focus, fantasy, intricate, highly detailed, digital painting, artstation, matte, sharp focus, illustration, art by magali villeneuve, chippy, ryan yee, rk post, clint cearley, daniel ljunggren, zoltan boros, gabor szikszai, howard lyon, steve argyle, winona nelson    - ghost inside a hunted room, art by lois van baarle and loish and ross tran and rossdraws and sam yang and samdoesarts and artgerm, digital art, highly detailed, intricate, sharp focus, Trending on Artstation HQ, deviantart, unreal engine 5, 4K UHD image    - red dead redemption 2, cinematic view, epic sky, detailed, concept art, low angle, high detail, warm lighting, volumetric, godrays, vivid, beautiful, trending on artstation, by jordan grimmer, huge scene, grass, art greg rutkowski    - a fantasy style portrait painting of rachel lane / alison brie hybrid in the style of francois boucher oil painting unreal 5 daz. rpg portrait, extremely detailed artgerm greg rutkowski alphonse mucha greg hildebrandt tim hildebrandt    - athena, greek goddess, claudia black, art by artgerm and greg rutkowski and magali villeneuve, bronze greek armor, owl crown, d & d, fantasy, intricate, portrait, highly detailed, headshot, digital painting, trending on artstation, concept art, sharp focus, illustration    - closeup portrait shot of a large strong female biomechanic woman in a scenic scifi environment, intricate, elegant, highly detailed, centered, digital painting, artstation, concept art, smooth, sharp focus, warframe, illustration, thomas kinkade, tomasz alen kopera, peter mohrbacher, donato giancola, leyendecker, boris vallejo    - ultra realistic illustration of steve urkle as the hulk, intricate, elegant, highly detailed, digital painting, artstation, concept art, smooth, sharp focus, illustration, art by artgerm and greg rutkowski and alphonse mucha
    I want you to write me a list of detailed prompts exactly about the idea written after IDEA. Follow the structure of the example prompts. This means a very short description of the scene, followed by modifiers divided by commas to alter the mood, style, lighting, and more.
    IDEA: {idea}""")    return res

class PromptGenerateInput(BaseModel):    """    生成英文提示词所需的输入模型类    """    idea: str = Field()

class GenerateImageInput(BaseModel):    """    生成图片所需的输入模型类    """    prompt: str = Field(description="英文提示词")

tools = [    Tool.from_function(        func=random_poem,        name="诗歌获取",        description="随机返回中文的诗词"    ),    Tool.from_function(        func=prompt_generate,        name="提示词生成",        description="生成图片需要对应的英文提示词，当前工具可以将输入转换为英文提示词，以便方便生成",        args_schema=PromptGenerateInput    ),    Tool.from_function(        func=generate_image,        name="图片生成",        description="根据提示词生成对应的图片，提示词需要是英文的，返回是图片的路径",        args_schema=GenerateImageInput    ),]

def main():    """    主函数，初始化代理并执行对话    """    llm = OpenAI(temperature=0)    agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)    agent.run("帮我生成一张诗词的图片?")

if __name__ == '__main__':    main()

import osfrom langchain.chains import RetrievalQAfrom langchain.document_loaders import TextLoaderfrom langchain.embeddings import OpenAIEmbeddingsfrom langchain.indexes import VectorstoreIndexCreatorfrom langchain.text_splitter import CharacterTextSplitterfrom langchain.vectorstores import Chromafrom langchain.llms import OpenAI
# 设置代理os.environ['HTTP_PROXY'] = 'socks5h://127.0.0.1:13659'os.environ['HTTPS_PROXY'] = 'socks5h://127.0.0.1:13659'
# 创建文本加载器loader = TextLoader('/Users/aihe/Downloads/demo.txt', encoding='utf8')
# 加载文档documents = loader.load()
# 文本分块text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)texts = text_splitter.split_documents(documents)
# 计算嵌入向量embeddings = OpenAIEmbeddings()
# 创建向量库db = Chroma.from_documents(texts, embeddings)
# 将向量库转换为检索器retriever = db.as_retriever()
# 创建检索问答系统qa = RetrievalQA.from_chain_type(llm=OpenAI(), chain_type="stuff", retriever=retriever)
# 运行问题答案检索query = "如何申请租户?"print(qa.run(query))
print(qa.run("能否说明下你可以提供的功能？"))

import requestsfrom langchain.agents import AgentType, initialize_agentfrom langchain.chat_models import ChatOpenAIfrom langchain.tools import StructuredToolfrom pydantic import BaseModel, Field

def post_message(type: str, param: dict) -> str:    """     当需要生成人群、分析画像、咨询问题时，使用如下的指示：url 固定为：http://localhost:3001/     如果请求是生成人群，请求的type为crowd; 如果请求是分析画像，请求的type为analyze; 如果是其他或者答疑，请求的type为question;     请求body的param把用户指定的条件传进来即可     """    result = requests.post("http://localhost:3001/", json={"type": type, "param": param})    return f"Status: {result.status_code} - {result.text}"

class PostInput(BaseModel):    # body: dict = Field(description="""格式:{"type":"","param":{}}""")    type: str = Field(description="请求的类型，人群为crowd,画像为analyze")    param: dict = Field(description="请求的具体描述")

llm = ChatOpenAI(temperature=0)tools = [    StructuredTool.from_function(post_message)]agent = initialize_agent(tools, llm, agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION, verbose=True)agent.run("我想生成一个性别为男并且在180天访问过淘特的人群?")

pip install langflow

langfow

FROM python:3.10-slim
RUN apt-get update && apt-get install gcc g++ git make -yRUN useradd -m -u 1000 userUSER userENV HOME=/home/user \    PATH=/home/user/.local/bin:$PATH
WORKDIR $HOME/app
COPY --chown=user . $HOME/app
RUN pip install langflow>==0.0.71 -U --userCMD ["langflow", "--host", "0.0.0.0", "--port", "7860"]