Skip to content

Building AI agents, atomically

12.5 KB
Raw Blame
"""FastAPI application for conversational AI with session management."""

import json
import uuid
from contextlib import asynccontextmanager
from datetime import datetime
from typing import Dict

from atomic_agents import AtomicAgent
from fastapi import FastAPI, HTTPException
from fastapi.responses import StreamingResponse

from fastapi_memory.lib.agents.chat_agent import create_async_chat_agent, create_chat_agent
from fastapi_memory.lib.schemas import (
    ChatRequest,
    ChatResponse,
    ConversationHistory,
    ConversationMessage,
    SessionCreateResponse,
    SessionDeleteResponse,
    SessionInfo,
    UserSessionsResponse,
)

# Session storage: user_id -> session_id -> agent
sessions: Dict[str, Dict[str, AtomicAgent[ChatRequest, ChatResponse]]] = {}
async_sessions: Dict[str, Dict[str, AtomicAgent[ChatRequest, ChatResponse]]] = {}

# Session metadata: user_id -> session_id -> creation_timestamp
session_metadata: Dict[str, Dict[str, str]] = {}

# Conversation history: user_id -> session_id -> list of messages
conversation_history: Dict[str, Dict[str, list]] = {}


def _generate_session_id() -> str:
    """Generate a unique session identifier.

    Returns:
        UUID-based session identifier
    """
    return str(uuid.uuid4())


def _ensure_user_exists(user_id: str) -> None:
    """Ensure user exists in all storage dictionaries.

    Args:
        user_id: User identifier
    """
    if user_id not in sessions:
        sessions[user_id] = {}
    if user_id not in async_sessions:
        async_sessions[user_id] = {}
    if user_id not in session_metadata:
        session_metadata[user_id] = {}
    if user_id not in conversation_history:
        conversation_history[user_id] = {}


def _ensure_session_history_exists(user_id: str, session_id: str) -> None:
    """Ensure conversation history exists for a session.

    Args:
        user_id: User identifier
        session_id: Session identifier
    """
    _ensure_user_exists(user_id)
    if session_id not in conversation_history[user_id]:
        conversation_history[user_id][session_id] = []


def _add_message_to_history(
    user_id: str,
    session_id: str,
    role: str,
    content: str,
    suggested_questions: list[str] = None,
) -> None:
    """Add a message to the conversation history.

    Args:
        user_id: User identifier
        session_id: Session identifier
        role: Message role (user or assistant)
        content: Message content
        suggested_questions: Optional list of suggested questions
    """
    _ensure_session_history_exists(user_id, session_id)
    message = {
        "role": role,
        "content": content,
        "timestamp": datetime.now().isoformat(),
        "suggested_questions": suggested_questions,
    }
    conversation_history[user_id][session_id].append(message)


def get_or_create_agent(user_id: str, session_id: str) -> AtomicAgent[ChatRequest, ChatResponse]:
    """Get existing agent or create new synchronous agent for the session.

    Args:
        user_id: User identifier
        session_id: Session identifier

    Returns:
        AtomicAgent configured for synchronous chat operations
    """
    _ensure_user_exists(user_id)
    if session_id not in sessions[user_id]:
        sessions[user_id][session_id] = create_chat_agent()
        if session_id not in session_metadata[user_id]:
            session_metadata[user_id][session_id] = datetime.now().isoformat()
    return sessions[user_id][session_id]


def get_or_create_async_agent(user_id: str, session_id: str) -> AtomicAgent[ChatRequest, ChatResponse]:
    """Get existing agent or create new asynchronous agent for the session.

    Args:
        user_id: User identifier
        session_id: Session identifier

    Returns:
        AtomicAgent configured for asynchronous streaming operations
    """
    _ensure_user_exists(user_id)
    if session_id not in async_sessions[user_id]:
        async_sessions[user_id][session_id] = create_async_chat_agent()
        if session_id not in session_metadata[user_id]:
            session_metadata[user_id][session_id] = datetime.now().isoformat()
    return async_sessions[user_id][session_id]


@asynccontextmanager
async def lifespan(app: FastAPI):
    """Application lifespan manager to clean up resources on shutdown.

    Args:
        app: FastAPI application instance

    Yields:
        None
    """
    yield
    sessions.clear()
    async_sessions.clear()
    session_metadata.clear()
    conversation_history.clear()


app = FastAPI(
    title="Atomic Agents FastAPI Example",
    description="Simple example showing FastAPI integration with Atomic Agents",
    version="1.0.0",
    lifespan=lifespan,
)


@app.post("/chat", response_model=ChatResponse, tags=["Chat"])
async def chat(request: ChatRequest) -> ChatResponse:
    """Process a chat message using non-streaming response.

    Args:
        request: Chat request containing message, user_id, and optional session ID

    Returns:
        ChatResponse with agent's reply and suggested questions

    Raises:
        HTTPException: If message processing fails
    """
    try:
        if not request.session_id:
            raise HTTPException(
                status_code=400, detail="session_id is required. Create a session first using POST /users/{user_id}/sessions"
            )

        # Store user message in history
        _add_message_to_history(request.user_id, request.session_id, "user", request.message)

        agent = get_or_create_agent(request.user_id, request.session_id)

        result = agent.run(ChatRequest(message=request.message, user_id=request.user_id))

        # Store assistant response in history
        _add_message_to_history(
            request.user_id,
            request.session_id,
            "assistant",
            result.response,
            getattr(result, "suggested_questions", None),
        )

        return ChatResponse(
            response=result.response,
            session_id=request.session_id,
            suggested_questions=getattr(result, "suggested_questions", None),
        )

    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))
    except Exception as e:
        import traceback

        traceback.print_exc()
        raise HTTPException(status_code=500, detail=f"Failed to process message: {str(e)}")


@app.post("/chat/stream", tags=["Chat"])
async def chat_stream(request: ChatRequest) -> StreamingResponse:
    """Process a chat message using streaming response.

    Args:
        request: Chat request containing message, user_id, and optional session ID

    Returns:
        StreamingResponse with Server-Sent Events format

    Raises:
        HTTPException: If streaming setup fails
    """
    try:
        if not request.session_id:
            raise HTTPException(
                status_code=400, detail="session_id is required. Create a session first using POST /users/{user_id}/sessions"
            )

        # Store user message in history
        _add_message_to_history(request.user_id, request.session_id, "user", request.message)

        agent = get_or_create_async_agent(request.user_id, request.session_id)

        async def generate():
            """Generate Server-Sent Events stream."""
            full_response = ""
            final_suggested_questions = []
            try:
                async for chunk in agent.run_async_stream(ChatRequest(message=request.message, user_id=request.user_id)):
                    chunk_dict = chunk.model_dump() if hasattr(chunk, "model_dump") else {}
                    response_text = chunk_dict.get("response", "")
                    full_response = response_text  # Keep updating with latest full text

                    if chunk_dict.get("suggested_questions"):
                        final_suggested_questions = chunk_dict.get("suggested_questions")

                    data = {
                        "response": response_text,
                        "session_id": request.session_id,
                        "suggested_questions": chunk_dict.get("suggested_questions"),
                    }
                    yield f"data: {json.dumps(data)}\n\n"

                # Store complete assistant response in history
                if full_response:
                    _add_message_to_history(
                        request.user_id,
                        request.session_id,
                        "assistant",
                        full_response,
                        final_suggested_questions,
                    )

            except Exception as e:
                error_data = {
                    "error": str(e),
                    "session_id": request.session_id,
                }
                yield f"data: {json.dumps(error_data)}\n\n"

        return StreamingResponse(generate(), media_type="text/event-stream")

    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Failed to setup stream: {str(e)}")


@app.post("/users/{user_id}/sessions", response_model=SessionCreateResponse, tags=["Sessions"])
async def create_session(user_id: str) -> SessionCreateResponse:
    """Create a new chat session for a user.

    Args:
        user_id: User identifier

    Returns:
        SessionCreateResponse with generated session ID

    Raises:
        HTTPException: If session creation fails
    """
    try:
        _ensure_user_exists(user_id)
        session_id = _generate_session_id()
        session_metadata[user_id][session_id] = datetime.now().isoformat()

        return SessionCreateResponse(session_id=session_id, message=f"Session '{session_id}' created successfully")

    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Failed to create session: {str(e)}")


@app.get("/users/{user_id}/sessions", response_model=UserSessionsResponse, tags=["Sessions"])
async def get_user_sessions(user_id: str) -> UserSessionsResponse:
    """Get all sessions for a specific user.

    Args:
        user_id: User identifier

    Returns:
        UserSessionsResponse with list of user's sessions
    """
    _ensure_user_exists(user_id)

    # Collect all unique session IDs for this user from both dicts
    sync_sessions = set(sessions.get(user_id, {}).keys())
    async_session_ids = set(async_sessions.get(user_id, {}).keys())
    all_session_ids = sync_sessions | async_session_ids

    # Build session info list
    session_list = [
        SessionInfo(session_id=sid, created_at=session_metadata.get(user_id, {}).get(sid)) for sid in sorted(all_session_ids)
    ]

    return UserSessionsResponse(user_id=user_id, sessions=session_list)


@app.get("/users/{user_id}/sessions/{session_id}/history", response_model=ConversationHistory, tags=["Sessions"])
async def get_conversation_history(user_id: str, session_id: str) -> ConversationHistory:
    """Get conversation history for a specific session.

    Args:
        user_id: User identifier
        session_id: Session identifier

    Returns:
        ConversationHistory with all messages in the session

    Raises:
        HTTPException: If session is not found
    """
    _ensure_session_history_exists(user_id, session_id)

    messages = conversation_history.get(user_id, {}).get(session_id, [])

    return ConversationHistory(session_id=session_id, messages=[ConversationMessage(**msg) for msg in messages])


@app.delete("/users/{user_id}/sessions/{session_id}", response_model=SessionDeleteResponse, tags=["Sessions"])
async def delete_session(user_id: str, session_id: str) -> SessionDeleteResponse:
    """Delete a specific session for a user.

    Args:
        user_id: User identifier
        session_id: Session identifier to delete

    Returns:
        SessionDeleteResponse with success message

    Raises:
        HTTPException: If session is not found
    """
    found = False

    if user_id in sessions and session_id in sessions[user_id]:
        del sessions[user_id][session_id]
        found = True

    if user_id in async_sessions and session_id in async_sessions[user_id]:
        del async_sessions[user_id][session_id]
        found = True

    if user_id in session_metadata and session_id in session_metadata[user_id]:
        del session_metadata[user_id][session_id]

    if user_id in conversation_history and session_id in conversation_history[user_id]:
        del conversation_history[user_id][session_id]

    if not found:
        raise HTTPException(status_code=404, detail=f"Session '{session_id}' not found for user '{user_id}'")

    return SessionDeleteResponse(message=f"Session '{session_id}' deleted successfully")


if __name__ == "__main__":
    import uvicorn

    uvicorn.run(app, host="0.0.0.0", port=8000)