Day05 MCP → Day06 · 保险顾问 Agent 后端（大白话版）

app/
├── main.py                      开机总装：启动流程、注册接口
├── core/config.py               配置中心（数据库/模型/报警）
├── common/models.py             表的"祖爷爷" + 时间戳工具
├── infra/
│   ├── database.py              业务库的连接池
│   └── checkpointer.py          Agent 记事本(连接池)
├── agents/insurance_advisor_agent.py   接线员本体
└── modules/
    ├── chat_thread/             档案柜：会话管理 + 翻历史(5.5)
    └── chat/                    传声筒：SSE 流式对话

client = MultiServerMCPClient({
    "time-mcp": { "transport": "stdio", "args": ["-y", "time-mcp"], "command": "npx" },
    "12306-mcp": { "transport": "streamable_http", "url": "https://mcp.api-inference.modelscope.net/..." }
})
tools = await client.get_tools()

model = init_chat_model(model='deepseek-v4-flash',
    extra_body={'thinking': {'type': 'disabled'}})

agent = create_agent(model=model, tools=tools, system_prompt='你是我的AI智能伴侣')

response = await agent.ainvoke({
    'messages': [HumanMessage('帮我查下周四从郑州到北京的高铁票？')]
})

class DatabaseSettings(EnvSettings):
    @computed_field
    @property
    def url(self) -> str:
        return self.build_url("postgresql+asyncpg")
    @computed_field
    @property
    def checkpoint_url(self) -> str:
        return self.build_url("postgresql")

settings = Settings()

class Base(DeclarativeBase):
    def __repr__(self): ...

class CreateAtMixin:
    created_at: Mapped[datetime] = mapped_column(
        DateTime(timezone=True), server_default=func.now())

class UpdateAtMixin:
    updated_at: Mapped[datetime] = mapped_column(
        DateTime(timezone=True),
        server_default=func.now(), onupdate=func.now())

engine = create_async_engine(DATABASE_URL, echo=settings.db.echo,
    pool_size=5, max_overflow=10, pool_pre_ping=True)

AsyncSessionFactory = async_sessionmaker(bind=engine,
    autoflush=False, expire_on_commit=False)

async def get_session():
    async with AsyncSessionFactory() as session:
        yield session

checkpoint_pool = AsyncConnectionPool(
    conninfo=settings.db.checkpoint_url,
    min_size=1, max_size=5,
    kwargs={
        "autocommit": True,
        "prepare_threshold": 0,
        "row_factory": dict_row,
    },
    open=False,
)

async def init_checkpointer():
    await checkpoint_pool.open()
    await checkpoint_pool.wait()
    checkpointer = AsyncPostgresSaver(checkpoint_pool)
    await checkpointer.setup()
    return checkpointer

async def close_checkpointer():
    await checkpoint_pool.close()

SYSTEM_PROMPT = """
你是"安心保"的智能保险顾问。
你需要使用专业、准确、容易理解的语言回答用户的保险问题。
当信息不足时，应先向用户追问，不要编造保险产品或保障内容。
"""

def init_agent(checkpointer: AsyncPostgresSaver):
    tools=[]   # ← 现在空的！MCP 讲的那个 get_tools() 没接进来

    model = init_chat_model(
        model=settings.llm.chat_model, api_key=settings.llm.api_key,
        extra_body={"thinking": {"type": "disabled"}})

    agent = create_agent(
        model=model, tools=tools,
        checkpointer=checkpointer,
        system_prompt=SYSTEM_PROMPT)
    return agent

class ChatRequest(BaseModel):
    thread_id: UUID = Field(description='会话ID')
    message: str  = Field(min_length=1, description='用户消息')

event: message
data: 你

event: message
data: 好

event: done
data: [done]

def get_service(request, session = Depends(get_session)):
    service = ChatService(request.app.state.agent, session)
    return service

@router.post("/chat", response_class=EventSourceResponse)
async def chat(chat_request: ChatRequest,
   user_id: Annotated[int, Header(alias="x-user-id")],
   service: ChatService = Depends(get_service)):
    message = service.chat_stream(chat_request, user_id)
    async for sse in message:
       yield sse

async def chat_stream(self, chat_request, user_id):
    # 1.校验：这个会话是你吗
    chat_thread = await self.repository.find_owned(chat_request.thread_id, user_id)
    if chat_thread is None:
        raise ChatThreadNotFoundError()

    # 2.告诉 Agent 用哪把钥匙
    config = {'configurable': {'thread_id': str(chat_request.thread_id)}}
    stream = await self.agent.astream_events(
        {'messages': [HumanMessage(chat_request.message)]},
        config, version='v3')

    # 3.逐字推给前端
    async for message in stream.messages:
        async for chunk in message.text:
            yield ServerSentEvent(data=chunk, event='message')

    # 4.说完了，结束
    yield ServerSentEvent(data=f'[done]', event='done')

class ChatThread(Base, CreateAtMixin, UpdateAtMixin):
    __tablename__ = "chat_threads"
    id: Mapped[UUID] = mapped_column(PG_UUID(as_uuid=True), primary_key=True, default=uuid4)
    user_id: Mapped[int] = mapped_column(BigInteger)
    title:  Mapped[str] = mapped_column(String(200), default="新会话", server_default="新会话")

async def find_owned(self, thread_id: UUID, user_id: int) -> ChatThread | None:
    return await self.session.scalar(
        select(ChatThread).where(
            ChatThread.id == thread_id,
            ChatThread.user_id == user_id,
        ))

async def add(self, user_id, title):
    async with self.session.begin():
        chat_thread = ChatThread(user_id=user_id, title=title)
        await self.repository.add(chat_thread)
        return chat_thread

async def rename(self, thread_id, user_id, title):
    async with self.session.begin():
        thread = await self.repository.find_owned(thread_id, user_id)
        if thread is None:
            raise ChatThreadNotFoundError
        thread.title = title
        await self.session.flush()
        await self.session.refresh(thread)
    return thread

@router.get('/{thread_id}/messages')
async def get_history_message(request, thread_id):
    agent = request.app.state.agent
    config = {'configurable': {'thread_id': thread_id}}
    snapshot = await agent.aget_state(config)

    messages = snapshot.values.get('messages', [])
    chat_messages = []
    for message in messages:
        if isinstance(message, HumanMessage):       role = 'user'
        elif isinstance(message, AIMessage):         role = 'assistant'
        content = message.text
        if content:
            chat_messages.append(ChatResponse(role=role, content=content))

    return ChatHistoryResponse(thread_id=thread_id, messages=chat_messages)

@asynccontextmanager
async def lifespan(app):
    await check_database()
    checkpointer = await init_checkpointer()
    app.state.agent = init_agent(checkpointer)
    yield
    await close_database(); await close_checkpointer()

app.add_middleware(CORSMiddleware,
    allow_origins=["http://localhost:5173", "http://127.0.0.1:5173"])

@app.exception_handler(ApplicationError)
async def handle_application_error(request, exc):
    return JSONResponse(status_code=exc.status_code,
        content={"code": exc.code, "message": exc.message})

app.include_router(chat_thread_router)
app.include_router(chat_router)

# 1. 建会话
curl -X POST http://localhost:8001/api/v1/chat-threads \
     -H "Content-Type: application/json" -H "x-user-id: 1" -d '{"title":"我的咨询"}'

# 2. 发一句话（会以 SSE 逐字返回）
curl -N -X POST http://localhost:8001/api/v1/chat \
     -H "Content-Type: application/json" -H "x-user-id: 1" \
     -d '{"thread_id":"$TID","message":"你好"}'

# 3. 5.5 翻历史
curl -H "x-user-id: 1" http://localhost:8001/api/v1/chat-threads/$TID/messages