from langchain_openai import ChatOpenAIfrom langchain_core.messages import HumanMessage
chat = ChatOpenAI(model=MODEL_NAME, temperature=0.2)chat.invoke([HumanMessage(content="My name is Joe. I would like to learn more about in-memory data stores!")])
# 内存数据存储是一种数据库管理系统，它将数据存储在计算机的主内存中，而不是在磁盘上。# 这允许更快地访问数据，因为不需要从磁盘读取或写入数据。

from sqlalchemy import Boolean, Column, ForeignKey, Integer, Stringfrom sqlalchemy.orm import relationship
from database import Base
class ChatSession(Base):__tablename__ = "chat_sessions"
id = Column(Integer, primary_key=True)llm_name = Column(String, nullable=False)
chat_histories = relationship("ChatHistory", back_populates="chat_session")

class ChatHistory(Base):__tablename__ = "chat_histories"
id = Column(Integer, primary_key=True)chat_session_id = Column(Integer, ForeignKey("chat_sessions.id"), nullable=False)is_human_message = Column(Boolean, nullable=False)content = Column(String, nullable=False)
chat_session = relationship("ChatSession", back_populates="chat_histories")

@app.post("/chat")async def new_chat( chat_message_human: ChatMessageCreate, db: Session = Depends(get_db_session), df: Dragonfly = Depends(get_dragonfly), chat: ChatOpenAI = Depends(get_chat),) -> service.ChatSessionResponse: # 调用 OpenAI API 获取 AI 响应。 message = HumanMessage(content=chat_message_human.content) chat_message_ai = chat.invoke([message])
 # 创建一个新的聊天会话，包含前两个聊天历史记录条目。 chat_session = ChatSessionCreate(llm_name=LARGE_LANGUAGE_MODEL_NAME) new_chat_histories = __messages_to_histories(chat_message_human, chat_message_ai) srv = service.DataService(db, df) chat_session_response = srv.create_chat_session(chat_session, new_chat_histories) return chat_session_response

@app.patch("/chat/{chat_id}")async def continue_chat( chat_id: int, chat_message_human: ChatMessageCreate, db: Session = Depends(get_db_session), df: Dragonfly = Depends(get_dragonfly), chat: ChatOpenAI = Depends(get_chat),) -> service.ChatSessionResponse: # 检查聊天会话是否存在并加载聊天历史记录。 srv = service.DataService(db, df) prev_chat_session_response = srv.read_chat_histories(chat_id) if prev_chat_session_response is None: raise HTTPException(status_code=404, detail="chat not found")
 # 从聊天历史记录构建消息，然后附加新的用户消息。 chat_histories = prev_chat_session_response.chat_histories messages = [] for i in range(len(chat_histories)): if chat_histories[i].is_human_message: messages.append(HumanMessage(content=chat_histories[i].content)) else: messages.append(AIMessage(content=chat_histories[i].content)) messages.append(HumanMessage(content=chat_message_human.content))
 # 调用 OpenAI API 获取 AI 响应。 chat_message_ai = chat.invoke(messages)
 # 将两个聊天历史记录条目添加到现有聊天会话中。 new_chat_histories = __messages_to_histories(chat_message_human, chat_message_ai) chat_session_response = srv.add_chat_histories(prev_chat_session_response, new_chat_histories) return chat_session_response

{	"chat_session_id": 1,	"chat_histories": [		{			"id": 1,			"content": "I want to learn more about in-memory data store.",			"is_human_message": true		},		{			"id": 2,			"content": "An in-memory data store is a type of database management system that stores data in the main memory
 of a computer rather than on a disk or other storage device...",			"is_human_message": false		},		{			"id": 3,			"content": "What are some good use cases?",			"is_human_message": true		},		{			"id": 4,			"content": "In-memory data stores are well-suited for a variety of use cases where speed, performance, and real-time data access are critical. Some common use cases for in-memory data stores include:...",			"is_human_message": false		}	]}

@app.get("/chat/{chat_id}")async def read_chat_histories(chat_id: int,db: Session = Depends(get_db_session),df: Dragonfly = Depends(get_dragonfly),) -> service.ChatSessionResponse:srv = service.DataService(db, df)chat_session_response = srv.read_chat_histories(chat_id)if chat_session_response is None:raise HTTPException(status_code=404, detail="chat not found")return chat_session_response

def read_chat_histories(self, chat_session_id: int) -> Union[ChatSessionResponse, None]:# 检查聊天历史记录是否缓存于 Dragonfly。cache_svc = _DataCacheService(self.df)chat_history_responses = cache_svc.read_chat_histories(chat_session_id)if chat_history_responses is not None and len(chat_history_responses) > 0:return ChatSessionResponse(chat_session_id, chat_history_responses)# 如果聊天历史记录未缓存于 Dragonfly，则从数据库读取并缓存于 Dragonfly。chat_histories = self.db.query(models.ChatHistory) \.filter(models.ChatHistory.chat_session_id == chat_session_id) \.order_by(models.ChatHistory.id) \.limit(100) \.all()if chat_histories is None or len(chat_histories) == 0:return None
chat_history_responses = [ChatHistoryResponse(v.id, v.content, v.is_human_message) for v in chat_histories]cache_svc.add_chat_histories(chat_session_id, chat_history_responses)return ChatSessionResponse(chat_session_id, chat_history_responses)