实践指南：易速鲜花聊天机器人开发与部署 | 豆包MarsCode AI刷题

小斑我想起舞了
4 阅读4分钟

项目目标

开发一个智能聊天机器人，提供以下功能：

  1. 基本对话：实现流畅自然的人机对话。
  2. 记忆能力：记住用户输入的上下文，提供连贯的交互。
  3. 文档检索：基于企业内部文档提供专业答案。
  4. 数据库查询 ：查询订单或库存信息。
  5. 部署到Web平台：使用Streamlit或Gradio创建用户友好的交互界面。

技术栈

  • 核心库：LangChain
  • 额外依赖：Flask、Streamlit、Gradio、Qdrant、OpenAI Embeddings
  • 语言：Python

项目分步实施

第一步：构建基础对话机器人

实现基本对话模型

-   使用LangChain的 `ChatOpenAI` 模型提供流畅的对话能力。
-   定义提示模板，引导机器人扮演“花卉行家”。

```
from langchain.chat_models import ChatOpenAI
from langchain.schema import HumanMessage, SystemMessage

chat = ChatOpenAI()

messages = [    SystemMessage(content="你是一个花卉行家。"),    HumanMessage(content="推荐适合婚礼的花。")]

response = chat(messages)
print(response.content)
```

第二步：增强记忆功能

使用ConversationBufferMemory

-   为机器人添加对话记忆功能，记住上下文内容。

```
from langchain.memory import ConversationBufferMemory
from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.chains import LLMChain

memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)

prompt = ChatPromptTemplate(
    messages=[
        MessagesPlaceholder(variable_name="chat_history"),
        SystemMessage(content="你是一个花卉行家。"),
        HumanMessage(content="{question}")
    ]
)

chat_with_memory = LLMChain(
    llm=ChatOpenAI(),
    prompt=prompt,
    memory=memory
)
```

第三步：添加文档检索功能

  1. 加载和分割文档

    • 使用LangChain的 DocumentLoader 和 RecursiveCharacterTextSplitter 对企业文档进行分割。
    from langchain.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter

loader = TextLoader("path/to/document.txt")
documents = loader.load()

text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
docs = text_splitter.split_documents(documents)

  2. 构建向量数据库

    • 使用 Qdrant 和 OpenAI Embeddings 存储分块的文档。
    from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Qdrant

vectorstore = Qdrant.from_documents(
    docs,
    embedding=OpenAIEmbeddings(),
    location=":memory:"
)

  3. 设置检索链

    • 将向量数据库集成到检索链中，支持问题回答。
    from langchain.chains import ConversationalRetrievalChain

retriever = vectorstore.as_retriever()
retrieval_chain = ConversationalRetrievalChain.from_llm(
    llm=ChatOpenAI(),
    retriever=retriever
)

第四步：数据库查询功能

  1. 数据库配置与模型定义

    • 定义基础的 SQLite 数据库模型。
from sqlalchemy import create_engine, Column, Integer, String, Float, Date
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

# SQLite 数据库连接
DATABASE_URL = "sqlite:///FlowerShop.db"
engine = create_engine(DATABASE_URL)
Base = declarative_base()

# 定义 Flowers 表
class Flowers(Base):
    __tablename__ = 'Flowers'
    ID = Column(Integer, primary_key=True, autoincrement=True)
    Name = Column(String, nullable=False)
    Type = Column(String, nullable=False)
    Source = Column(String, nullable=False)
    PurchasePrice = Column(Float)
    SalePrice = Column(Float)
    StockQuantity = Column(Integer)
    SoldQuantity = Column(Integer)
    ExpiryDate = Column(Date)
    Description = Column(String)

# 创建会话
Session = sessionmaker(bind=engine)
session = Session()

  1. LLM 查询集成

    • 借助 LangChain 提供的 SQLDatabaseChain 和 SQL Agent，实现自然语言与数据库的无缝交互。
SQL Chain
from langchain.utilities import SQLDatabase
from langchain.llms import OpenAI
from langchain_experimental.sql import SQLDatabaseChain

# 连接数据库
db = SQLDatabase.from_uri(DATABASE_URL)
llm = OpenAI(temperature=0)

# 创建 SQL Chain
db_chain = SQLDatabaseChain.from_llm(llm, db, verbose=True)

def query_with_sql_chain(user_input):
    try:
        return db_chain.run(user_input)
    except Exception as e:
        return f"查询失败: {e}"
SQL Agent
from langchain.agents import create_sql_agent
from langchain.agents.agent_toolkits import SQLDatabaseToolkit
from langchain.agents.agent_types import AgentType

# 创建 SQL Agent
toolkit = SQLDatabaseToolkit(db=db, llm=llm)
agent_executor = create_sql_agent(
    llm=llm,
    toolkit=toolkit,
    verbose=True,
    agent_type=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
)

def query_with_sql_agent(user_input):
    try:
        return agent_executor.run(user_input)
    except Exception as e:
        return f"查询失败: {e}"

  1. 与 Chatbot 集成

    • 将数据库查询功能嵌入到 Chatbot 的对话流程中。
class ChatbotWithDatabase:
    def __init__(self):
        self.sql_chain = query_with_sql_chain
        self.sql_agent = query_with_sql_agent

    def process_query(self, user_input):
        if "通过 Chain 查询" in user_input:
            return self.sql_chain(user_input.replace("通过 Chain 查询", "").strip())
        elif "通过 Agent 查询" in user_input:
            return self.sql_agent(user_input.replace("通过 Agent 查询", "").strip())
        else:
            return "请明确您是要通过 Chain 还是 Agent 进行查询。"

# 示例交互
chatbot = ChatbotWithDatabase()
print(chatbot.process_query("通过 Chain 查询 哪种鲜花的存货数量最少？"))
print(chatbot.process_query("通过 Agent 查询 去年的总销售额是多少？"))

第五步：部署聊天机器人

方案1：使用Streamlit

  1. 安装依赖

    pip install streamlit

  2. 实现Streamlit应用

    • 创建用户界面，并整合检索功能。
    import streamlit as st

def main():
    st.title("易速鲜花智能客服")
    user_input = st.text_input("请输入问题：")
    if user_input:
        response = retrieval_chain({"question": user_input})
        st.write(f"Chatbot: {response['answer']}")

if __name__ == "__main__":
    main()

  3. 运行程序

    streamlit run chatbot_streamlit.py
方案2：使用Gradio

  1. 安装依赖

    pip install gradio

  2. 实现Gradio界面

    • 使用简单接口完成交互。
    import gradio as gr

def chatbot_response(user_input):
    response = retrieval_chain({"question": user_input})
    return response['answer']

interface = gr.Interface(
    fn=chatbot_response,
    inputs="text",
    outputs="text",
    title="易速鲜花智能客服"
)

if __name__ == "__main__":
    interface.launch()

总结与扩展

通过本指南完成以下功能：

  1. 实现了基本聊天能力。
  2. 添加了对话记忆功能。
  3. 集成了企业文档的检索能力。
  4. 通过Streamlit或Gradio成功部署到Web平台。

改进方向

  1. 更智能的检索：优化文档分块策略，提高相关性。
  2. 多模态支持：支持图片输入，识别花卉或产品。
  3. 美化界面：增强用户体验，提升品牌价值。
  4. 多语言支持：扩展成多语言客服机器人。
avatar
文章
阅读
粉丝