# 创建并激活虚拟环境
python -m venv langchain-env
source langchain-env/bin/activate  # Linux/Mac
.\langchain-env\Scripts\activate   # Windows

# 安装核心依赖
pip install langchain==0.1.0 langchain-core==0.1.0 langchain-community==0.1.0
pip install openai==1.12.0 pandas==2.1.0 scikit-learn==1.3.0

# 示例：基础架构类设计
from langchain_core.language_models import BaseLanguageModel
from langchain_core.memory import BaseMemory

class EnterpriseLangChainApp:
    def __init__(self, llm: BaseLanguageModel, memory: BaseMemory):
        self.llm = llm          # 模型服务层
        self.memory = memory    # 记忆管理

    def process_input(self, user_input: str):
        """业务逻辑层核心方法"""
        # 预处理输入
        processed_input = self._preprocess(user_input)
        # 生成响应
        response = self.llm.generate(processed_input)
        # 后处理输出
        return self._postprocess(response)

    def _preprocess(self, text: str) -> str:
        """数据预处理"""
        return text.lower().strip()

    def _postprocess(self, response: str) -> dict:
        """结果后处理"""
        return {"response": response, "timestamp": datetime.now()}

from langchain_openai import ChatOpenAI
from langchain.chains import LLMChain

# 使用GPT-4-turbo作为基础模型（实际使用时替换为你的API key）
llm = ChatOpenAI(
    model="gpt-4-turbo-preview",
    temperature=0.7,
    openai_api_key="your-api-key"
)

# 验证模型连接（重要！企业应用中必须添加健康检查）
try:
    llm.invoke("ping")
    print("✅ Model connection successful")
except Exception as e:
    print(f"❌ Model connection failed: {str(e)}")

from langchain_community.document_loaders import CSVLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter

# 加载产品知识CSV（示例文件）
loader = CSVLoader(file_path="product_knowledge.csv")
documents = loader.load()

# 文档分块处理（关键参数需要根据实际数据调整）
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    length_function=len,
    is_separator_regex=False,
)

docs = text_splitter.split_documents(documents)
print(f"知识库加载完成，共{len(docs)}个文档块")

from langchain_community.vectorstores import FAISS
from langchain_openai import OpenAIEmbeddings

# 使用OpenAI的嵌入模型（也可以换成其他嵌入模型）
embeddings = OpenAIEmbeddings(model="text-embedding-3-large")

# ⚠️注意：大数据集需要分批处理避免内存溢出！
vector_db = FAISS.from_documents(
    documents=docs[:500],   # 先处理前500条测试效果 
    embedding=embeddings,
)

# 保存向量数据库到本地（生产环境应该用专业向量数据库）
vector_db.save_local("faiss_index")

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough

# RAG提示模板（这是实际项目中需要反复优化的部分）
template = """你是一个专业的产品客服助手，请根据以下上下文回答问题：
{context}

问题：{question}
请用中文给出专业、详细的回答："""
prompt = ChatPromptTemplate.from_template(template)

retriever = vector_db.as_retriever(search_kwargs={"k":3})   # top3相关文档

rag_chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt 
    | llm 
)

# ⭐️测试RAG效果⭐️ 
response = rag_chain.invoke("你们的产品A支持哪些支付方式？")
print(response.content)

from typing import List, Dict  
from datetime import datetime  
from langchain_core.messages import HumanMessage, AIMessage  
from langchain_community.chat_message_histories import RedisChatMessageHistory  

class CustomerSupportAgent:  
    def __init__(self, user_id: str):  
        self.user_id = user_id  

        # Redis存储对话历史（生产环境推荐配置）  
        self.message_history = RedisChatMessageHistory(  
            url="redis://localhost:6379/0",  
            session_id=f"cs_session_{user_id}",  
            ttl=3600*24*7   #7天过期  
        )  

        # RAG+对话链组合  
        self.conversation_chain = (  
            self._load_context() 
            | prompt 
            | llm.bind(stop=["\nCustomer:"])  
        )  

    def _load_context(self):  
        """组合历史对话和检索到的上下文"""  
        return RunnablePassthrough.assign(  
            context=lambda x: self._retrieve_context(x["question"]),  
            chat_history=lambda _: self._format_history(),  
        )  

    def _retrieve_context(self, question: str) -> str:  
        """检索相关知识"""  
        docs = retriever.invoke(question)  
        return "\n\n".join([d.page_content for d in docs])  

    def _format_history(self) -> str:  
        """格式化对话历史"""  
        history_msgs = []  

         for msg in self.message_history.messages[-6:]:   #最多保留6轮对话   
             if isinstance(msg, HumanMessage):   
                 history_msgs.append(f"Customer:{msg.content}")   
             elif isinstance(msg, AIMessage):   
                 history_msgs.append(f"Agent:{msg.content}")   

         return "\n".join(history_msgs) if history_msgs else "No history yet"  

     def respond(self, user_input: str) -> Dict[str, str]:   
         """处理用户输入并返回响应"""   
         try:   
             start_time = datetime.now()   

             #记录用户消息   
             self.message_history.add_user_message(user_input)   

             #生成响应   
             response_msg : AIMessage= self.conversation_chain.invoke({"question":user_input})    
             response_text=response_msg.content    

             #记录AI回复    
             self.message_history.add_ai_message(response_text)    

             return {    
                 "response": response_text,    
                 "time_cost": (datetime.now()-start_time).total_seconds(),    
                 "status":"success"    
             }    
         except Exception as e:
            return {
                "error": str(e),
                "status": "failed"
            }

# 🚀使用示例🚀            
agent = CustomerSupportAgent(user_id="test123")  

while True:
    query=input("\n用户提问:")

     if query.lower() in ["exit","quit"]:
         break

     result=agent.respond(query)

     if result["status"]=="success":
         print(f"\n🤖客服助手:",result["response"])
         print(f"⏱️耗时:{result['time_cost']:.2f}s")
     else:
         print("❌发生错误:",result["error"])