Skip to content

Building AI agents, atomically

Update model names, finish FastAPI implementation

KennyVaneetvelde398d5c655365
diff --git a/README.md b/README.md
index ccdfd49..6fd1295 100644
--- a/README.md
+++ b/README.md
@@ -112,7 +112,7 @@ client = instructor.from_openai(OpenAI())
agent = AtomicAgent[BasicChatInputSchema, CustomOutputSchema](
config=AgentConfig(
client=client,
- model="gpt-4o-mini",
+ model="gpt-5-mini",
system_prompt_generator=system_prompt_generator,
history=ChatHistory(),
)
@@ -219,7 +219,7 @@ class QueryAgentInputSchema(BaseIOSchema):
query_agent = AtomicAgent[QueryAgentInputSchema, SearXNGSearchTool.input_schema](
config=AgentConfig(
client=instructor.from_openai(openai.OpenAI()),
- model="gpt-4o-mini",
+ model="gpt-5-mini",
system_prompt_generator=SystemPromptGenerator(
background=[
"You are an intelligent query generation expert.",
diff --git a/UPGRADE_DOC.md b/UPGRADE_DOC.md
index 38581e3..6d05df5 100644
--- a/UPGRADE_DOC.md
+++ b/UPGRADE_DOC.md
@@ -182,7 +182,7 @@ client = instructor.from_openai(OpenAI())
agent = BaseAgent(
BaseAgentConfig(
client=client,
- model="gpt-4o-mini",
+ model="gpt-5-mini",
memory=AgentMemory()
# No schema parameters = uses BaseAgentInputSchema and BaseAgentOutputSchema
)
@@ -192,7 +192,7 @@ agent = BaseAgent(
agent = BaseAgent(
BaseAgentConfig(
client=client,
- model="gpt-4o-mini",
+ model="gpt-5-mini",
memory=AgentMemory(),
input_schema=CustomInputSchema, # Passed in config
output_schema=CustomOutputSchema # Passed in config
@@ -226,7 +226,7 @@ client = instructor.from_openai(OpenAI())
agent = AtomicAgent[BasicChatInputSchema, BasicChatOutputSchema](
AgentConfig(
client=client,
- model="gpt-4o-mini",
+ model="gpt-5-mini",
history=ChatHistory()
)
)
@@ -235,7 +235,7 @@ agent = AtomicAgent[BasicChatInputSchema, BasicChatOutputSchema](
agent = AtomicAgent[CustomInputSchema, CustomOutputSchema](
AgentConfig(
client=client,
- model="gpt-4o-mini",
+ model="gpt-5-mini",
history=ChatHistory()
# No schema parameters in config!
)
@@ -262,7 +262,7 @@ agent = AtomicAgent[CustomInputSchema, CustomOutputSchema](
agent = BaseAgent(
BaseAgentConfig(
client=client,
- model="gpt-4o-mini",
+ model="gpt-5-mini",
memory=AgentMemory(),
input_schema=TranslationInput, # Was here
output_schema=TranslationOutput # Was here
@@ -273,7 +273,7 @@ agent = AtomicAgent[CustomInputSchema, CustomOutputSchema](
agent = AtomicAgent[TranslationInput, TranslationOutput](
AgentConfig(
client=client,
- model="gpt-4o-mini",
+ model="gpt-5-mini",
history=ChatHistory() # Note: memory → history
# Schemas no longer in config!
)
@@ -285,7 +285,7 @@ agent = AtomicAgent[CustomInputSchema, CustomOutputSchema](
# OLD - Direct parameters
config = BaseAgentConfig(
client=client,
- model="gpt-4o-mini",
+ model="gpt-5-mini",
memory=AgentMemory(), # Old field name
temperature=0.7, # Direct parameter
max_tokens=1000 # Direct parameter
@@ -294,7 +294,7 @@ agent = AtomicAgent[CustomInputSchema, CustomOutputSchema](
# NEW - Grouped parameters
config = AgentConfig(
client=client,
- model="gpt-4o-mini",
+ model="gpt-5-mini",
history=ChatHistory(), # New field name
model_api_parameters={ # Temperature and max_tokens moved here
"temperature": 0.7,
@@ -347,7 +347,7 @@ from atomic_agents.context import ChatHistory
client = instructor.from_openai(OpenAI())
agent = AtomicAgent[BasicChatInputSchema, BasicChatOutputSchema](
- AgentConfig(client=client, model="gpt-4o-mini", history=ChatHistory())
+ AgentConfig(client=client, model="gpt-5-mini", history=ChatHistory())
)
# Non-streaming (same as v1.x) - Wait for complete response
@@ -372,7 +372,7 @@ import asyncio
client = instructor.from_openai(AsyncOpenAI())
agent = AtomicAgent[BasicChatInputSchema, BasicChatOutputSchema](
- AgentConfig(client=client, model="gpt-4o-mini", history=ChatHistory())
+ AgentConfig(client=client, model="gpt-5-mini", history=ChatHistory())
)
# OLD (v1.x) - run_async was a streaming generator
@@ -605,7 +605,7 @@ system_prompt = SystemPromptGenerator(
agent = BaseAgent(
BaseAgentConfig(
client=client,
- model="gpt-4o-mini",
+ model="gpt-5-mini",
memory=memory,
system_prompt_generator=system_prompt,
input_schema=SupportTicketInput,
@@ -663,7 +663,7 @@ system_prompt = SystemPromptGenerator(
agent = AtomicAgent[SupportTicketInput, SupportTicketOutput]( # Schemas as type parameters
AgentConfig(
client=client,
- model="gpt-4o-mini",
+ model="gpt-5-mini",
history=history, # Changed from memory
system_prompt_generator=system_prompt,
# No input_schema or output_schema in config
diff --git a/agents.md b/agents.md
index 5464272..6b5546e 100644
--- a/agents.md
+++ b/agents.md
@@ -333,7 +333,7 @@ agent = AtomicAgent(
system_prompt="You are a helpful assistant. Provide accurate answers.",
input_schema=InputSchema,
output_schema=OutputSchema,
- model="gpt-4o-mini",
+ model="gpt-5-mini",
)
# Run agent
diff --git a/atomic-agents/atomic_agents/agents/atomic_agent.py b/atomic-agents/atomic_agents/agents/atomic_agent.py
index a8782da..24e4071 100644
--- a/atomic-agents/atomic_agents/agents/atomic_agent.py
+++ b/atomic-agents/atomic_agents/agents/atomic_agent.py
@@ -60,7 +60,7 @@ class BasicChatOutputSchema(BaseIOSchema):
class AgentConfig(BaseModel):
client: instructor.client.Instructor = Field(..., description="Client for interacting with the language model.")
- model: str = Field(default="gpt-4o-mini", description="The model to use for generating responses.")
+ model: str = Field(default="gpt-5-mini", description="The model to use for generating responses.")
history: Optional[ChatHistory] = Field(default=None, description="History component for storing chat history.")
system_prompt_generator: Optional[SystemPromptGenerator] = Field(
default=None, description="Component for generating system prompts."
@@ -579,11 +579,11 @@ if __name__ == "__main__":
"""
if streaming:
client = instructor.from_openai(AsyncOpenAI())
- config = AgentConfig(client=client, model="gpt-4o-mini")
+ config = AgentConfig(client=client, model="gpt-5-mini")
agent = AtomicAgent[BasicChatInputSchema, BasicChatOutputSchema](config)
else:
client = instructor.from_openai(OpenAI())
- config = AgentConfig(client=client, model="gpt-4o-mini")
+ config = AgentConfig(client=client, model="gpt-5-mini")
agent = AtomicAgent[BasicChatInputSchema, BasicChatOutputSchema](config)
# Display agent information before starting the chat
diff --git a/atomic-agents/tests/agents/test_atomic_agent.py b/atomic-agents/tests/agents/test_atomic_agent.py
index c526d47..9778ec8 100644
--- a/atomic-agents/tests/agents/test_atomic_agent.py
+++ b/atomic-agents/tests/agents/test_atomic_agent.py
@@ -76,7 +76,7 @@ def mock_system_prompt_generator():
def agent_config(mock_instructor, mock_history, mock_system_prompt_generator):
return AgentConfig(
client=mock_instructor,
- model="gpt-4o-mini",
+ model="gpt-5-mini",
history=mock_history,
system_prompt_generator=mock_system_prompt_generator,
)
@@ -91,7 +91,7 @@ def agent(agent_config):
def agent_config_async(mock_instructor_async, mock_history, mock_system_prompt_generator):
return AgentConfig(
client=mock_instructor_async,
- model="gpt-4o-mini",
+ model="gpt-5-mini",
history=mock_history,
system_prompt_generator=mock_system_prompt_generator,
)
@@ -104,7 +104,7 @@ def agent_async(agent_config_async):
def test_initialization(agent, mock_instructor, mock_history, mock_system_prompt_generator):
assert agent.client == mock_instructor
- assert agent.model == "gpt-4o-mini"
+ assert agent.model == "gpt-5-mini"
assert agent.history == mock_history
assert agent.system_prompt_generator == mock_system_prompt_generator
assert "max_tokens" not in agent.model_api_parameters
@@ -114,7 +114,7 @@ def test_initialization(agent, mock_instructor, mock_history, mock_system_prompt
def test_initialization_temperature_priority(mock_instructor, mock_history, mock_system_prompt_generator):
config = AgentConfig(
client=mock_instructor,
- model="gpt-4o-mini",
+ model="gpt-5-mini",
history=mock_history,
system_prompt_generator=mock_system_prompt_generator,
model_api_parameters={"temperature": 1.0},
@@ -126,7 +126,7 @@ def test_initialization_temperature_priority(mock_instructor, mock_history, mock
def test_initialization_without_temperature(mock_instructor, mock_history, mock_system_prompt_generator):
config = AgentConfig(
client=mock_instructor,
- model="gpt-4o-mini",
+ model="gpt-5-mini",
history=mock_history,
system_prompt_generator=mock_system_prompt_generator,
model_api_parameters={"temperature": 0.5},
@@ -138,7 +138,7 @@ def test_initialization_without_temperature(mock_instructor, mock_history, mock_
def test_initialization_without_max_tokens(mock_instructor, mock_history, mock_system_prompt_generator):
config = AgentConfig(
client=mock_instructor,
- model="gpt-4o-mini",
+ model="gpt-5-mini",
history=mock_history,
system_prompt_generator=mock_system_prompt_generator,
model_api_parameters={"max_tokens": 1024},
@@ -150,7 +150,7 @@ def test_initialization_without_max_tokens(mock_instructor, mock_history, mock_s
def test_initialization_system_role_equals_developer(mock_instructor, mock_history, mock_system_prompt_generator):
config = AgentConfig(
client=mock_instructor,
- model="gpt-4o-mini",
+ model="gpt-5-mini",
history=mock_history,
system_prompt_generator=mock_system_prompt_generator,
system_role="developer",
@@ -164,7 +164,7 @@ def test_initialization_system_role_equals_developer(mock_instructor, mock_histo
def test_initialization_system_role_equals_None(mock_instructor, mock_history, mock_system_prompt_generator):
config = AgentConfig(
client=mock_instructor,
- model="gpt-4o-mini",
+ model="gpt-5-mini",
history=mock_history,
system_prompt_generator=mock_system_prompt_generator,
system_role=None,
@@ -215,7 +215,7 @@ def test_unregister_context_provider(agent, mock_system_prompt_generator):
def test_no_type_parameters(mock_instructor):
custom_config = AgentConfig(
client=mock_instructor,
- model="gpt-4o-mini",
+ model="gpt-5-mini",
)
custom_agent = AtomicAgent(custom_config)
@@ -233,7 +233,7 @@ def test_custom_input_output_schemas(mock_instructor):
custom_config = AgentConfig(
client=mock_instructor,
- model="gpt-4o-mini",
+ model="gpt-5-mini",
)
custom_agent = AtomicAgent[CustomInputSchema, CustomOutputSchema](custom_config)
@@ -256,7 +256,7 @@ def test_subclass_with_custom_constructor(mock_instructor):
self.extra_param = extra_param
config = AgentConfig(
client=mock_instructor,
- model="gpt-4o-mini",
+ model="gpt-5-mini",
)
super().__init__(config)
@@ -319,7 +319,7 @@ def test_run_stream(mock_instructor, mock_history):
# Create a AgentConfig with system_role set to None
config = AgentConfig(
client=mock_instructor,
- model="gpt-4o-mini",
+ model="gpt-5-mini",
history=mock_history,
system_prompt_generator=None, # No system prompt generator
)
@@ -457,7 +457,7 @@ def test_hook_registration_with_instructor_client(mock_instructor):
mock_instructor.off = Mock()
mock_instructor.clear = Mock()
- config = AgentConfig(client=mock_instructor, model="gpt-4o-mini")
+ config = AgentConfig(client=mock_instructor, model="gpt-5-mini")
agent = AtomicAgent[BasicChatInputSchema, BasicChatOutputSchema](config)
def test_handler(error):
@@ -629,7 +629,7 @@ def test_agent_initialization_includes_hooks(mock_instructor, mock_history, mock
"""Test that agent initialization properly sets up hook system."""
config = AgentConfig(
client=mock_instructor,
- model="gpt-4o-mini",
+ model="gpt-5-mini",
history=mock_history,
system_prompt_generator=mock_system_prompt_generator,
)
@@ -665,7 +665,7 @@ def test_backward_compatibility_no_breaking_changes(mock_instructor, mock_histor
config = AgentConfig(
client=mock_instructor,
- model="gpt-4o-mini",
+ model="gpt-5-mini",
history=mock_history,
system_prompt_generator=mock_system_prompt_generator,
)
@@ -674,7 +674,7 @@ def test_backward_compatibility_no_breaking_changes(mock_instructor, mock_histor
# Test that all existing attributes still exist and work
assert agent.client == mock_instructor
- assert agent.model == "gpt-4o-mini"
+ assert agent.model == "gpt-5-mini"
assert agent.history == mock_history
assert agent.system_prompt_generator == mock_system_prompt_generator
diff --git a/atomic-examples/fastapi-memory/README.md b/atomic-examples/fastapi-memory/README.md
index 95b10b3..7f5701f 100644
--- a/atomic-examples/fastapi-memory/README.md
+++ b/atomic-examples/fastapi-memory/README.md
@@ -1,13 +1,18 @@
# FastAPI with Atomic Agents
-A simple example demonstrating how to integrate Atomic Agents with FastAPI for building stateful conversational APIs.
+A comprehensive example demonstrating how to integrate Atomic Agents with FastAPI for building multi-user, multi-session conversational APIs.
## Features
-- Session-based conversation management
-- RESTful API endpoints for chat interactions
-- Automatic session creation and cleanup
-- Environment-based configuration
+- **Multi-user support**: Each user can have multiple independent chat sessions
+- **Conversation history**: Full conversation history is stored and restored when you return to a session
+- **User ID persistence**: Client automatically generates and stores a persistent user ID
+- **Auto-generated session IDs**: Sessions are created with UUIDs - no manual IDs needed
+- **Session management**: View, create, and delete sessions per user
+- **RESTful API**: Clean endpoints for chat and session management
+- **Interactive CLI client**: Rich terminal interface with session selection
+- **Streaming support**: Both standard and streaming chat responses
+- **Type safety**: Pydantic schemas for request/response validation
## Setup
@@ -28,6 +33,27 @@ OPENAI_API_KEY=your_openai_api_key
## Running the Example
+### Option 1: Interactive Client (Recommended)
+
+Start the server:
+```bash
+poetry run python fastapi_memory/main.py
+```
+
+In a separate terminal, run the interactive client:
+```bash
+poetry run python fastapi_memory/client.py
+```
+
+The client will:
+1. Auto-generate and persist a user ID (stored in `~/.fastapi_memory_user_id`)
+2. Show your existing chat sessions or prompt you to create one
+3. Load full conversation history when you select an existing session
+4. Let you chat in streaming or non-streaming mode (type `/exit` to go back)
+5. Manage your sessions (view/delete)
+
+### Option 2: Direct API Usage
+
Start the FastAPI server:
```bash
poetry run python fastapi_memory/main.py
@@ -41,53 +67,162 @@ Once running, visit:
- Interactive API docs: `http://localhost:8000/docs`
- Alternative docs: `http://localhost:8000/redoc`
-## Usage Examples
+## API Usage Examples
-### Send a message (creates new session automatically):
+### 1. Create a new session for a user:
```bash
-curl -X POST "http://localhost:8000/chat" \
- -H "Content-Type: application/json" \
- -d '{"message": "Hello, what can you help me with?"}'
+curl -X POST "http://localhost:8000/users/user123/sessions"
+```
+Response:
+```json
+{
+ "session_id": "550e8400-e29b-41d4-a716-446655440000",
+ "message": "Session created successfully"
+}
```
-### Continue a conversation with session ID:
+### 2. Get all sessions for a user:
+```bash
+curl "http://localhost:8000/users/user123/sessions"
+```
+Response:
+```json
+{
+ "user_id": "user123",
+ "sessions": [
+ {
+ "session_id": "550e8400-e29b-41d4-a716-446655440000",
+ "created_at": "2025-01-23T10:30:00"
+ }
+ ]
+}
+```
+
+### 3. Send a chat message:
```bash
curl -X POST "http://localhost:8000/chat" \
-H "Content-Type: application/json" \
- -d '{"message": "Tell me more about that", "session_id": "user123"}'
+ -d '{
+ "message": "Hello, how are you?",
+ "user_id": "user123",
+ "session_id": "550e8400-e29b-41d4-a716-446655440000"
+ }'
```
-### List active sessions:
+### 4. Get conversation history for a session:
```bash
-curl "http://localhost:8000/sessions"
+curl "http://localhost:8000/users/user123/sessions/550e8400-e29b-41d4-a716-446655440000/history"
+```
+Response:
+```json
+{
+ "session_id": "550e8400-e29b-41d4-a716-446655440000",
+ "messages": [
+ {
+ "role": "user",
+ "content": "Hello, how are you?",
+ "timestamp": "2025-01-23T10:31:00"
+ },
+ {
+ "role": "assistant",
+ "content": "I'm doing well, thank you for asking!",
+ "timestamp": "2025-01-23T10:31:02",
+ "suggested_questions": [
+ "What can you do?",
+ "Tell me a joke",
+ "How does this work?"
+ ]
+ }
+ ]
+}
```
-### Clear a specific session:
+### 5. Delete a session:
```bash
-curl -X DELETE "http://localhost:8000/sessions/user123"
+curl -X DELETE "http://localhost:8000/users/user123/sessions/550e8400-e29b-41d4-a716-446655440000"
+```
+
+### 6. Test the API:
+```bash
+poetry run python test_api.py
```
## How It Works
-The example demonstrates several key patterns:
+The example demonstrates several key architectural patterns:
+
+### Server Architecture
+
+1. **Multi-User Session Management**:
+ - Data structure: `user_id → session_id → agent_instance`
+ - Each user can have unlimited independent chat sessions
+ - Sessions are isolated - no data leakage between users or sessions
+
+2. **Conversation History Storage**:
+ - All messages are stored with timestamps
+ - Separate storage: `user_id → session_id → messages[]`
+ - History persists across client reconnections
+ - Automatically loaded when resuming a session
+
+3. **Auto-Generated Session IDs**:
+ - Server generates UUIDs for new sessions
+ - Eliminates user input errors and collisions
+ - Tracked with creation timestamps
+
+4. **Lazy Initialization**:
+ - Agent instances created on-demand when first accessed
+ - Reduces memory footprint for inactive sessions
+ - Conversation history maintained independently
+
+5. **Proper Lifecycle Management**:
+ - Lifespan context manager ensures cleanup on shutdown
+ - Memory released when sessions are deleted
+ - History cleared along with session deletion
+
+6. **Type Safety**:
+ - Pydantic schemas validate all requests/responses
+ - Clear API contracts with automatic documentation
+
+### Client Architecture
-1. **Session Management**: Each session maintains its own agent instance with independent conversation history.
+1. **User ID Persistence**:
+ - Client generates a UUID on first run
+ - Stored in `~/.fastapi_memory_user_id`
+ - Reused across sessions for continuity
-2. **Lazy Initialization**: Agent instances are created on-demand when a session is first accessed.
+2. **Session Discovery**:
+ - Fetches user's sessions from server on startup
+ - Displays sessions with creation timestamps
+ - Allows selection or creation of new sessions
-3. **Automatic Cleanup**: The lifespan context manager ensures proper cleanup when the application shuts down.
+3. **Conversation History Loading**:
+ - Automatically fetches history when loading a session
+ - Displays full conversation context before continuing
+ - Seamlessly resume conversations from where you left off
-4. **Type Safety**: Uses Pydantic schemas for request/response validation.
+4. **Rich Terminal UI**:
+ - Interactive menus with Rich library
+ - Streaming and non-streaming chat modes
+ - Session management interface
+ - Type `/exit` to return to menu (not Escape)
## Project Structure
```
fastapi-memory/
-├── pyproject.toml # Project dependencies
-├── .env.example # Environment variable template
-├── README.md # This file
+├── pyproject.toml # Project dependencies
+├── .env.example # Environment variable template
+├── README.md # This file
+├── test_api.py # API testing script
└── fastapi_memory/
- └── main.py # FastAPI application
+ ├── __init__.py
+ ├── main.py # FastAPI server
+ ├── client.py # Interactive CLI client
+ └── lib/
+ ├── agents/
+ │ └── chat_agent.py # Agent configuration
+ ├── config.py # Configuration constants
+ └── schemas.py # Pydantic schemas
```
## Related Examples
diff --git a/atomic-examples/fastapi-memory/fastapi_memory/__init__.py b/atomic-examples/fastapi-memory/fastapi_memory/__init__.py
new file mode 100644
index 0000000..7a871ac
--- /dev/null
+++ b/atomic-examples/fastapi-memory/fastapi_memory/__init__.py
@@ -0,0 +1,3 @@
+"""FastAPI Atomic Agents example - Conversational AI with session management."""
+
+__version__ = "1.0.0"
diff --git a/atomic-examples/fastapi-memory/fastapi_memory/client.py b/atomic-examples/fastapi-memory/fastapi_memory/client.py
new file mode 100644
index 0000000..c101c9f
--- /dev/null
+++ b/atomic-examples/fastapi-memory/fastapi_memory/client.py
@@ -0,0 +1,548 @@
+"""Interactive command-line client for the FastAPI Atomic Agents example.
+
+This client provides a user-friendly interface to interact with the FastAPI
+chat server, supporting both streaming and non-streaming modes, as well as
+session management capabilities.
+"""
+
+import asyncio
+import json
+import os
+import uuid
+from pathlib import Path
+from typing import List, Optional
+
+import httpx
+from rich.console import Console
+from rich.live import Live
+from rich.panel import Panel
+from rich.prompt import Prompt
+from rich.table import Table
+from rich.text import Text
+
+console = Console()
+
+# Configuration
+BASE_URL = os.getenv("FASTAPI_URL", "http://localhost:8000")
+REQUEST_TIMEOUT = 30.0
+USER_ID_FILE = Path.home() / ".fastapi_memory_user_id"
+
+
+def get_or_create_user_id() -> str:
+ """Get existing user ID from file or create a new one.
+
+ Returns:
+ User identifier (UUID)
+ """
+ if USER_ID_FILE.exists():
+ user_id = USER_ID_FILE.read_text().strip()
+ if user_id:
+ return user_id
+
+ # Generate new user ID
+ user_id = str(uuid.uuid4())
+ USER_ID_FILE.write_text(user_id)
+ console.print(f"[dim]Created new user ID: {user_id}[/dim]\n")
+ return user_id
+
+
+def _fetch_user_sessions(user_id: str) -> Optional[List[dict]]:
+ """Fetch the list of sessions for the current user.
+
+ Args:
+ user_id: User identifier
+
+ Returns:
+ List of session dicts with 'session_id' and 'created_at', or None if request failed
+ """
+ try:
+ response = httpx.get(f"{BASE_URL}/users/{user_id}/sessions", timeout=REQUEST_TIMEOUT)
+ response.raise_for_status()
+ data = response.json()
+ return data.get("sessions", [])
+ except Exception as e:
+ console.print(f"[bold red]Error fetching sessions:[/bold red] {str(e)}")
+ return None
+
+
+def _create_new_session(user_id: str) -> Optional[str]:
+ """Create a new session for the user.
+
+ Args:
+ user_id: User identifier
+
+ Returns:
+ New session ID or None if creation failed
+ """
+ try:
+ response = httpx.post(f"{BASE_URL}/users/{user_id}/sessions", timeout=REQUEST_TIMEOUT)
+ response.raise_for_status()
+ data = response.json()
+ return data.get("session_id")
+ except Exception as e:
+ console.print(f"[bold red]Error creating session:[/bold red] {str(e)}")
+ return None
+
+
+def _delete_session(user_id: str, session_id: str) -> bool:
+ """Delete a session.
+
+ Args:
+ user_id: User identifier
+ session_id: Session identifier to delete
+
+ Returns:
+ True if successful, False otherwise
+ """
+ try:
+ response = httpx.delete(
+ f"{BASE_URL}/users/{user_id}/sessions/{session_id}",
+ timeout=REQUEST_TIMEOUT
+ )
+ response.raise_for_status()
+ return True
+ except httpx.HTTPStatusError as e:
+ if e.response.status_code == 404:
+ console.print("\n[bold red]✗ Session not found[/bold red]")
+ else:
+ console.print(f"\n[bold red]HTTP Error {e.response.status_code}:[/bold red] {str(e)}")
+ return False
+ except Exception as e:
+ console.print(f"\n[bold red]Error:[/bold red] {str(e)}")
+ return False
+
+
+def select_or_create_session(user_id: str) -> Optional[str]:
+ """Show user's sessions and let them select one or create new.
+
+ Args:
+ user_id: User identifier
+
+ Returns:
+ Selected or newly created session ID, or None if cancelled
+ """
+ console.clear()
+ console.print(
+ Panel.fit(
+ "[bold magenta]Session Selection[/bold magenta]",
+ border_style="magenta",
+ )
+ )
+ console.print()
+
+ # Fetch existing sessions
+ sessions = _fetch_user_sessions(user_id)
+ if sessions is None:
+ console.print("[yellow]Could not fetch sessions. Try again?[/yellow]")
+ retry = Prompt.ask("Retry", choices=["yes", "no"], default="yes")
+ if retry == "yes":
+ return select_or_create_session(user_id)
+ return None
+
+ # Display sessions
+ if sessions:
+ console.print("[bold cyan]Your sessions:[/bold cyan]\n")
+ table = Table(show_header=True)
+ table.add_column("#", style="dim", width=4)
+ table.add_column("Session ID", style="cyan")
+ table.add_column("Created At", style="green")
+
+ for i, session in enumerate(sessions, 1):
+ created_at = session.get("created_at", "Unknown")
+ # Truncate session ID for display
+ display_id = session["session_id"][:8] + "..." if len(session["session_id"]) > 8 else session["session_id"]
+ table.add_row(str(i), display_id, created_at)
+
+ console.print(table)
+ console.print()
+
+ # Let user select
+ console.print("[dim]Options:[/dim]")
+ console.print(" [cyan]1-{}[/cyan]: Select existing session".format(len(sessions)))
+ console.print(" [cyan]new[/cyan]: Create new session")
+ console.print(" [cyan]cancel[/cyan]: Go back")
+ console.print()
+
+ choice = Prompt.ask("[bold yellow]Select option[/bold yellow]")
+
+ if choice.lower() == "cancel":
+ return None
+ elif choice.lower() == "new":
+ console.print("\n[dim]Creating new session...[/dim]")
+ session_id = _create_new_session(user_id)
+ if session_id:
+ console.print(f"[bold green]✓ Created session: {session_id[:8]}...[/bold green]\n")
+ Prompt.ask("[dim]Press Enter to continue[/dim]", default="")
+ return session_id
+ return None
+ else:
+ try:
+ index = int(choice) - 1
+ if 0 <= index < len(sessions):
+ return sessions[index]["session_id"]
+ else:
+ console.print("[bold red]Invalid selection[/bold red]")
+ Prompt.ask("[dim]Press Enter to try again[/dim]", default="")
+ return select_or_create_session(user_id)
+ except ValueError:
+ console.print("[bold red]Invalid input[/bold red]")
+ Prompt.ask("[dim]Press Enter to try again[/dim]", default="")
+ return select_or_create_session(user_id)
+ else:
+ console.print("[yellow]You don't have any sessions yet.[/yellow]\n")
+ create = Prompt.ask("Create new session", choices=["yes", "no"], default="yes")
+ if create == "yes":
+ console.print("\n[dim]Creating new session...[/dim]")
+ session_id = _create_new_session(user_id)
+ if session_id:
+ console.print(f"[bold green]✓ Created session: {session_id[:8]}...[/bold green]\n")
+ Prompt.ask("[dim]Press Enter to continue[/dim]", default="")
+ return session_id
+ return None
+
+
+def _fetch_conversation_history(user_id: str, session_id: str) -> Optional[List[dict]]:
+ """Fetch conversation history for a session.
+
+ Args:
+ user_id: User identifier
+ session_id: Session identifier
+
+ Returns:
+ List of message dicts with 'role', 'content', 'timestamp', or None if request failed
+ """
+ try:
+ response = httpx.get(
+ f"{BASE_URL}/users/{user_id}/sessions/{session_id}/history",
+ timeout=REQUEST_TIMEOUT
+ )
+ response.raise_for_status()
+ data = response.json()
+ return data.get("messages", [])
+ except Exception as e:
+ console.print(f"[bold red]Error fetching history:[/bold red] {str(e)}")
+ return None
+
+
+def _display_conversation_history(messages: List[dict]) -> None:
+ """Display conversation history.
+
+ Args:
+ messages: List of message dicts with 'role' and 'content'
+ """
+ if not messages:
+ return
+
+ console.print("[dim]─── Conversation History ───[/dim]\n")
+ for msg in messages:
+ role = msg.get("role", "unknown")
+ content = msg.get("content", "")
+
+ if role == "user":
+ console.print(Text("You:", style="bold blue"), end=" ")
+ console.print(content)
+ elif role == "assistant":
+ console.print(Text("Agent:", style="bold green"), end=" ")
+ console.print(Text(content, style="green"))
+
+ if msg.get("suggested_questions"):
+ _display_suggested_questions(msg["suggested_questions"])
+ console.print()
+
+ console.print("[dim]─── End of History ───[/dim]\n")
+
+
+def _display_suggested_questions(questions: List[str]) -> None:
+ """Display suggested follow-up questions.
+
+ Args:
+ questions: List of suggested question strings
+ """
+ if questions:
+ console.print("\n[bold cyan]Suggested questions:[/bold cyan]")
+ for i, question in enumerate(questions, 1):
+ console.print(f"[cyan]{i}. {question}[/cyan]")
+
+
+def chat_non_streaming(user_id: str, session_id: str) -> None:
+ """Run interactive chat in non-streaming mode.
+
+ Args:
+ user_id: User identifier
+ session_id: Session identifier
+ """
+ console.clear()
+ console.print(Panel("[bold cyan]Non-Streaming Chat Mode[/bold cyan]"))
+ console.print(f"[dim]Session: {session_id[:8]}...[/dim]")
+ console.print("[dim]Type '/exit' to return to menu[/dim]\n")
+
+ # Fetch and display conversation history
+ history = _fetch_conversation_history(user_id, session_id)
+ if history and len(history) > 0:
+ _display_conversation_history(history)
+ else:
+ # No history - show welcome message
+ console.print(Text("Agent:", style="bold green"), end=" ")
+ console.print("Hello! How can I assist you today?")
+
+ # Display initial suggested questions
+ initial_questions = [
+ "What can you help me with?",
+ "Tell me about your capabilities",
+ "How does this chat system work?"
+ ]
+ _display_suggested_questions(initial_questions)
+ console.print()
+
+ while True:
+ user_input = Prompt.ask("[bold blue]You[/bold blue]")
+
+ if user_input.lower() == "/exit":
+ break
+
+ try:
+ response = httpx.post(
+ f"{BASE_URL}/chat",
+ json={"message": user_input, "user_id": user_id, "session_id": session_id},
+ timeout=REQUEST_TIMEOUT,
+ )
+ response.raise_for_status()
+ data = response.json()
+
+ console.print()
+ console.print(Text("Agent:", style="bold green"), end=" ")
+ console.print(Text(data["response"], style="green"))
+
+ _display_suggested_questions(data.get("suggested_questions", []))
+ console.print()
+
+ except httpx.HTTPStatusError as e:
+ console.print(f"\n[bold red]HTTP Error {e.response.status_code}:[/bold red] {str(e)}\n")
+ except Exception as e:
+ console.print(f"\n[bold red]Error:[/bold red] {str(e)}\n")
+
+
+async def chat_streaming_async(user_id: str, session_id: str) -> None:
+ """Run interactive chat in streaming mode.
+
+ Args:
+ user_id: User identifier
+ session_id: Session identifier
+ """
+ console.clear()
+ console.print(Panel("[bold cyan]Streaming Chat Mode[/bold cyan]"))
+ console.print(f"[dim]Session: {session_id[:8]}...[/dim]")
+ console.print("[dim]Type '/exit' to return to menu[/dim]\n")
+
+ # Fetch and display conversation history
+ history = _fetch_conversation_history(user_id, session_id)
+ if history and len(history) > 0:
+ _display_conversation_history(history)
+ else:
+ # No history - show welcome message
+ console.print(Text("Agent:", style="bold green"), end=" ")
+ console.print("Hello! How can I assist you today?")
+
+ # Display initial suggested questions
+ initial_questions = [
+ "What can you help me with?",
+ "Tell me about your capabilities",
+ "How does this chat system work?"
+ ]
+ _display_suggested_questions(initial_questions)
+ console.print()
+
+ while True:
+ user_input = Prompt.ask("[bold blue]You[/bold blue]")
+
+ if user_input.lower() == "/exit":
+ break
+
+ try:
+ console.print()
+ async with httpx.AsyncClient() as client:
+ async with client.stream(
+ "POST",
+ f"{BASE_URL}/chat/stream",
+ json={"message": user_input, "user_id": user_id, "session_id": session_id},
+ timeout=REQUEST_TIMEOUT,
+ ) as response:
+ response.raise_for_status()
+
+ with Live("", refresh_per_second=10, auto_refresh=True) as live:
+ current_response = ""
+ current_questions = []
+
+ async for line in response.aiter_lines():
+ if line.startswith("data: "):
+ data_str = line[6:]
+ if data_str.strip():
+ data = json.loads(data_str)
+
+ if "error" in data:
+ console.print(
+ f"\n[bold red]Error:[/bold red] {data['error']}\n"
+ )
+ break
+
+ if data.get("response"):
+ current_response = data["response"]
+ if data.get("suggested_questions"):
+ current_questions = data["suggested_questions"]
+
+ display_text = Text.assemble(
+ ("Agent: ", "bold green"), (current_response, "green")
+ )
+
+ if current_questions:
+ display_text.append("\n\n")
+ display_text.append(
+ "Suggested questions:\n", style="bold cyan"
+ )
+ for i, question in enumerate(current_questions, 1):
+ display_text.append(f"{i}. {question}\n", style="cyan")
+
+ live.update(display_text)
+
+ console.print()
+
+ except httpx.HTTPStatusError as e:
+ console.print(f"\n[bold red]HTTP Error {e.response.status_code}:[/bold red] {str(e)}\n")
+ except Exception as e:
+ console.print(f"\n[bold red]Error:[/bold red] {str(e)}\n")
+
+
+def manage_sessions(user_id: str) -> None:
+ """Display and manage user's sessions.
+
+ Args:
+ user_id: User identifier
+ """
+ console.clear()
+ console.print(Panel("[bold cyan]Manage Sessions[/bold cyan]"))
+ console.print()
+
+ sessions = _fetch_user_sessions(user_id)
+ if sessions is None:
+ console.print()
+ Prompt.ask("[dim]Press Enter to continue[/dim]", default="")
+ return
+
+ if not sessions:
+ console.print("[yellow]No active sessions found[/yellow]")
+ console.print()
+ Prompt.ask("[dim]Press Enter to continue[/dim]", default="")
+ return
+
+ # Display sessions
+ console.print("[bold]Your sessions:[/bold]\n")
+ table = Table(show_header=True)
+ table.add_column("#", style="dim", width=4)
+ table.add_column("Session ID", style="cyan")
+ table.add_column("Created At", style="green")
+
+ for i, session in enumerate(sessions, 1):
+ created_at = session.get("created_at", "Unknown")
+ display_id = session["session_id"][:16]
+ table.add_row(str(i), display_id, created_at)
+
+ console.print(table)
+ console.print()
+
+ # Ask which to delete
+ console.print("[dim]Enter session number to delete, or 'cancel' to go back[/dim]")
+ choice = Prompt.ask("[bold yellow]Delete session[/bold yellow]", default="cancel")
+
+ if choice.lower() != "cancel":
+ try:
+ index = int(choice) - 1
+ if 0 <= index < len(sessions):
+ session_to_delete = sessions[index]["session_id"]
+ confirm = Prompt.ask(
+ f"\n[bold yellow]Delete session {session_to_delete[:8]}...?[/bold yellow]",
+ choices=["yes", "no"],
+ default="no"
+ )
+ if confirm == "yes":
+ if _delete_session(user_id, session_to_delete):
+ console.print(f"\n[bold green]✓ Session deleted[/bold green]")
+ else:
+ console.print("[bold red]Invalid selection[/bold red]")
+ except ValueError:
+ console.print("[bold red]Invalid input[/bold red]")
+
+ console.print()
+ Prompt.ask("[dim]Press Enter to continue[/dim]", default="")
+
+
+def show_main_menu(user_id: str) -> str:
+ """Display the main menu and get user's choice.
+
+ Args:
+ user_id: User identifier
+
+ Returns:
+ User's menu selection as a string
+ """
+ console.clear()
+ console.print(
+ Panel.fit(
+ "[bold magenta]FastAPI Atomic Agents - Interactive Client[/bold magenta]",
+ border_style="magenta",
+ )
+ )
+ console.print(f"[dim]User ID: {user_id[:8]}...[/dim]\n")
+
+ table = Table(show_header=False, box=None, padding=(0, 2))
+ table.add_column(style="cyan bold", justify="right")
+ table.add_column(style="white")
+
+ table.add_row("1", "Start Chat (Non-Streaming)")
+ table.add_row("2", "Start Chat (Streaming)")
+ table.add_row("3", "Manage Sessions")
+ table.add_row("4", "Exit")
+
+ console.print(table)
+ console.print()
+
+ choice = Prompt.ask(
+ "[bold yellow]Select an option[/bold yellow]",
+ choices=["1", "2", "3", "4"],
+ default="1",
+ )
+ return choice
+
+
+async def main() -> None:
+ """Main application loop."""
+ user_id = get_or_create_user_id()
+
+ while True:
+ choice = show_main_menu(user_id)
+
+ if choice == "1":
+ # Non-streaming chat
+ session_id = select_or_create_session(user_id)
+ if session_id:
+ chat_non_streaming(user_id, session_id)
+
+ elif choice == "2":
+ # Streaming chat
+ session_id = select_or_create_session(user_id)
+ if session_id:
+ await chat_streaming_async(user_id, session_id)
+
+ elif choice == "3":
+ # Manage sessions
+ manage_sessions(user_id)
+
+ elif choice == "4":
+ console.print("\n[bold cyan]Goodbye![/bold cyan]\n")
+ break
+
+
+if __name__ == "__main__":
+ try:
+ asyncio.run(main())
+ except KeyboardInterrupt:
+ console.print("\n\n[bold cyan]Goodbye![/bold cyan]\n")
diff --git a/atomic-examples/fastapi-memory/fastapi_memory/lib/__init__.py b/atomic-examples/fastapi-memory/fastapi_memory/lib/__init__.py
new file mode 100644
index 0000000..f28de8f
--- /dev/null
+++ b/atomic-examples/fastapi-memory/fastapi_memory/lib/__init__.py
@@ -0,0 +1 @@
+"""Library modules for FastAPI Atomic Agents example."""
diff --git a/atomic-examples/fastapi-memory/fastapi_memory/lib/agents/__init__.py b/atomic-examples/fastapi-memory/fastapi_memory/lib/agents/__init__.py
new file mode 100644
index 0000000..92f2456
--- /dev/null
+++ b/atomic-examples/fastapi-memory/fastapi_memory/lib/agents/__init__.py
@@ -0,0 +1,5 @@
+"""Agent implementations for FastAPI example."""
+
+from fastapi_memory.lib.agents.chat_agent import create_async_chat_agent, create_chat_agent
+
+__all__ = ["create_chat_agent", "create_async_chat_agent"]
diff --git a/atomic-examples/fastapi-memory/fastapi_memory/lib/agents/chat_agent.py b/atomic-examples/fastapi-memory/fastapi_memory/lib/agents/chat_agent.py
new file mode 100644
index 0000000..4243fdd
--- /dev/null
+++ b/atomic-examples/fastapi-memory/fastapi_memory/lib/agents/chat_agent.py
@@ -0,0 +1,70 @@
+"""Chat agent configuration and initialization."""
+
+import instructor
+import openai
+from atomic_agents import AgentConfig, AtomicAgent
+from atomic_agents.context import SystemPromptGenerator
+
+from fastapi_memory.lib.config import MODEL_NAME, NUM_SUGGESTED_QUESTIONS, get_api_key
+from fastapi_memory.lib.schemas import ChatRequest, ChatResponse
+
+
+def _create_system_prompt() -> SystemPromptGenerator:
+ """Create the system prompt configuration for chat agents.
+
+ Returns:
+ SystemPromptGenerator configured for conversational assistance
+ """
+ return SystemPromptGenerator(
+ background=["You are a helpful AI assistant that maintains conversation context."],
+ steps=[
+ "Understand the user's message",
+ "Provide a clear and helpful response",
+ f"Generate {NUM_SUGGESTED_QUESTIONS} example questions that the user could type to continue the conversation",
+ ],
+ output_instructions=[
+ "Be concise and friendly",
+ "Reference previous context when relevant",
+ "Suggested questions must be phrased as if the user is asking them (e.g., 'Tell me more about X', 'How does Y work?', 'What is Z?')",
+ ],
+ )
+
+
+def create_chat_agent() -> AtomicAgent[ChatRequest, ChatResponse]:
+ """Create a new synchronous chat agent.
+
+ Returns:
+ AtomicAgent configured for synchronous chat operations
+
+ Raises:
+ ValueError: If OPENAI_API_KEY environment variable is not set
+ """
+ api_key = get_api_key()
+ client = instructor.from_openai(openai.OpenAI(api_key=api_key))
+ config = AgentConfig(
+ client=client,
+ model=MODEL_NAME,
+ model_api_parameters={"reasoning_effort": "minimal"},
+ system_prompt_generator=_create_system_prompt(),
+ )
+ return AtomicAgent[ChatRequest, ChatResponse](config=config)
+
+
+def create_async_chat_agent() -> AtomicAgent[ChatRequest, ChatResponse]:
+ """Create a new asynchronous chat agent.
+
+ Returns:
+ AtomicAgent configured for asynchronous streaming operations
+
+ Raises:
+ ValueError: If OPENAI_API_KEY environment variable is not set
+ """
+ api_key = get_api_key()
+ client = instructor.from_openai(openai.AsyncOpenAI(api_key=api_key))
+ config = AgentConfig(
+ client=client,
+ model=MODEL_NAME,
+ model_api_parameters={"reasoning_effort": "minimal"},
+ system_prompt_generator=_create_system_prompt(),
+ )
+ return AtomicAgent[ChatRequest, ChatResponse](config=config)
diff --git a/atomic-examples/fastapi-memory/fastapi_memory/lib/config.py b/atomic-examples/fastapi-memory/fastapi_memory/lib/config.py
new file mode 100644
index 0000000..0ab4710
--- /dev/null
+++ b/atomic-examples/fastapi-memory/fastapi_memory/lib/config.py
@@ -0,0 +1,48 @@
+"""Configuration module for FastAPI Atomic Agents example."""
+
+import os
+
+
+def get_api_key() -> str:
+ """Get OpenAI API key from environment variables.
+
+ Returns:
+ str: OpenAI API key
+
+ Raises:
+ ValueError: If OPENAI_API_KEY environment variable is not set
+ """
+ api_key = os.getenv("OPENAI_API_KEY")
+ if api_key:
+ return api_key
+
+ # Fallback: Try to load from local .env or monorepo quickstart .env
+ # This is for development convenience in the atomic-monorepo
+ from pathlib import Path
+
+ search_paths = [
+ Path(".env"),
+ Path(r"C:\dev_new\BrainAtomics\atomic-monorepo\atomic-examples\quickstart\.env"),
+ ]
+
+ for env_path in search_paths:
+ if env_path.exists():
+ try:
+ content = env_path.read_text(encoding="utf-8")
+ for line in content.splitlines():
+ line = line.strip()
+ if line.startswith("OPENAI_API_KEY="):
+ return line.split("=", 1)[1].strip().strip('"').strip("'")
+ except Exception:
+ continue
+
+ raise ValueError(
+ "OPENAI_API_KEY environment variable is required. "
+ "Please set it or create a .env file."
+ )
+
+
+# Constants
+DEFAULT_SESSION_ID = "default"
+MODEL_NAME = "gpt-5-mini"
+NUM_SUGGESTED_QUESTIONS = 3
diff --git a/atomic-examples/fastapi-memory/fastapi_memory/lib/schemas.py b/atomic-examples/fastapi-memory/fastapi_memory/lib/schemas.py
new file mode 100644
index 0000000..d1bcd01
--- /dev/null
+++ b/atomic-examples/fastapi-memory/fastapi_memory/lib/schemas.py
@@ -0,0 +1,78 @@
+"""Schema definitions for FastAPI Atomic Agents example."""
+
+from typing import List, Optional
+
+from atomic_agents import BaseIOSchema
+from pydantic import Field
+
+
+class ChatRequest(BaseIOSchema):
+ """Request schema for chat endpoint."""
+
+ message: str = Field(..., description="User message")
+ user_id: str = Field(..., description="User identifier")
+ session_id: Optional[str] = Field(
+ None, description="Session identifier for conversation continuity"
+ )
+
+
+class ChatResponse(BaseIOSchema):
+ """Response schema for chat endpoint."""
+
+ response: str = Field(..., description="Agent response")
+ session_id: str = Field(..., description="Session identifier")
+ suggested_questions: Optional[List[str]] = Field(
+ None,
+ description="Suggested initial or follow-up questions that the user could ask the assistant",
+ )
+
+
+class SessionCreateRequest(BaseIOSchema):
+ """Request schema for creating a new session."""
+
+ user_id: str = Field(..., description="User identifier")
+
+
+class SessionCreateResponse(BaseIOSchema):
+ """Response schema for session creation."""
+
+ session_id: str = Field(..., description="Generated session identifier")
+ message: str = Field(..., description="Success message")
+
+
+class SessionInfo(BaseIOSchema):
+ """Information about a single session."""
+
+ session_id: str = Field(..., description="Session identifier")
+ created_at: Optional[str] = Field(None, description="Creation timestamp")
+
+
+class UserSessionsResponse(BaseIOSchema):
+ """Response schema for listing user's sessions."""
+
+ user_id: str = Field(..., description="User identifier")
+ sessions: List[SessionInfo] = Field(..., description="List of user's sessions")
+
+
+class SessionDeleteResponse(BaseIOSchema):
+ """Response schema for session deletion."""
+
+ message: str = Field(..., description="Status message")
+
+
+class ConversationMessage(BaseIOSchema):
+ """A single message in the conversation history."""
+
+ role: str = Field(..., description="Message role (user or assistant)")
+ content: str = Field(..., description="Message content")
+ timestamp: str = Field(..., description="Message timestamp")
+ suggested_questions: Optional[List[str]] = Field(
+ None, description="Suggested follow-up questions (only for assistant messages)"
+ )
+
+
+class ConversationHistory(BaseIOSchema):
+ """Conversation history for a session."""
+
+ session_id: str = Field(..., description="Session identifier")
+ messages: List[ConversationMessage] = Field(..., description="List of messages in chronological order")
diff --git a/atomic-examples/fastapi-memory/fastapi_memory/main.py b/atomic-examples/fastapi-memory/fastapi_memory/main.py
index c133e56..ef3690d 100644
--- a/atomic-examples/fastapi-memory/fastapi_memory/main.py
+++ b/atomic-examples/fastapi-memory/fastapi_memory/main.py
@@ -1,93 +1,406 @@
-import os
+"""FastAPI application for conversational AI with session management."""
+
+import json
+import uuid
from contextlib import asynccontextmanager
-from typing import Optional
+from datetime import datetime
+from typing import Dict
-import instructor
-import openai
-from atomic_agents import AtomicAgent, AgentConfig, BaseIOSchema
-from atomic_agents.context import SystemPromptGenerator
-from dotenv import load_dotenv
+from atomic_agents import AtomicAgent
from fastapi import FastAPI, HTTPException
-from pydantic import Field
+from fastapi.responses import StreamingResponse
-load_dotenv()
+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,
+ SessionCreateRequest,
+ 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]]] = {}
-class ChatRequest(BaseIOSchema):
- """Request schema for chat endpoint"""
+# Session metadata: user_id -> session_id -> creation_timestamp
+session_metadata: Dict[str, Dict[str, str]] = {}
- message: str = Field(..., description="User message")
- session_id: Optional[str] = Field(None, description="Session identifier for conversation continuity")
+# Conversation history: user_id -> session_id -> list of messages
+conversation_history: Dict[str, Dict[str, list]] = {}
-class ChatResponse(BaseIOSchema):
- """Response schema for chat endpoint"""
+def _generate_session_id() -> str:
+ """Generate a unique session identifier.
- response: str = Field(..., description="Agent response")
- session_id: str = Field(..., description="Session identifier")
+ Returns:
+ UUID-based session identifier
+ """
+ return str(uuid.uuid4())
-sessions = {}
+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 get_or_create_agent(session_id: str) -> AtomicAgent[ChatRequest, ChatResponse]:
- if session_id not in sessions:
- client = instructor.from_openai(openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY")))
- system_prompt = SystemPromptGenerator(
- background=["You are a helpful AI assistant that maintains conversation context."],
- steps=["Understand the user's message", "Provide a clear and helpful response"],
- output_instructions=["Be concise and friendly", "Reference previous context when relevant"],
- )
+def _ensure_session_history_exists(user_id: str, session_id: str) -> None:
+ """Ensure conversation history exists for a session.
- config = AgentConfig(
- client=client,
- model="gpt-4o-mini",
- system_prompt_generator=system_prompt,
- )
+ 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
- sessions[session_id] = AtomicAgent[ChatRequest, ChatResponse](config=config)
+ 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]
- return sessions[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,
)
[email protected]("/chat", response_model=ChatResponse)
-async def chat(request: ChatRequest):
[email protected]("/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:
- session_id = request.session_id or "default"
- agent = get_or_create_agent(session_id)
+ 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)
- result = agent.run(ChatRequest(message=request.message))
- return ChatResponse(response=result.response, session_id=session_id)
+ 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:
- raise HTTPException(status_code=500, detail=str(e))
+ import traceback
+
+ traceback.print_exc()
+ raise HTTPException(status_code=500, detail=f"Failed to process message: {str(e)}")
+
+
[email protected]("/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
[email protected]("/sessions/{session_id}")
-async def clear_session(session_id: str):
- if session_id in sessions:
- del sessions[session_id]
- return {"message": f"Session {session_id} cleared"}
- raise HTTPException(status_code=404, detail="Session not found")
+ 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)}")
+
+
[email protected]("/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)}")
+
+
[email protected]("/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
+ )
+
+
[email protected]("/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]
+ )
+
+
[email protected]("/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}'"
+ )
[email protected]("/sessions")
-async def list_sessions():
- return {"active_sessions": list(sessions.keys())}
+ return SessionDeleteResponse(message=f"Session '{session_id}' deleted successfully")
if __name__ == "__main__":
diff --git a/atomic-examples/fastapi-memory/poetry.lock b/atomic-examples/fastapi-memory/poetry.lock
index c4f1578..ddc0943 100644
--- a/atomic-examples/fastapi-memory/poetry.lock
+++ b/atomic-examples/fastapi-memory/poetry.lock
@@ -2990,4 +2990,4 @@ propcache = ">=0.2.1"
[metadata]
lock-version = "2.1"
python-versions = ">=3.12,<4.0"
-content-hash = "ee01474d8ad7533898d50819a3b71c3f4bc9dbf4f017353994a1b86bcc00bd74"
+content-hash = "3f17bea17e1b70d7486c3222406368f4057757673564d30747c4a3a5b68e5008"
diff --git a/atomic-examples/fastapi-memory/pyproject.toml b/atomic-examples/fastapi-memory/pyproject.toml
index 4dbac06..1810e22 100644
--- a/atomic-examples/fastapi-memory/pyproject.toml
+++ b/atomic-examples/fastapi-memory/pyproject.toml
@@ -13,7 +13,8 @@ uvicorn = "^0.32.1"
instructor = "==1.9.2"
openai = ">=1.0.0"
pydantic = ">=2.10.3,<3.0.0"
-python-dotenv = ">=1.0.1,<2.0.0"
+httpx = "^0.28.1"
+rich = "^13.9.4"
[build-system]
requires = ["poetry-core"]
diff --git a/atomic-examples/fastapi-memory/test_api.py b/atomic-examples/fastapi-memory/test_api.py
new file mode 100644
index 0000000..2056284
--- /dev/null
+++ b/atomic-examples/fastapi-memory/test_api.py
@@ -0,0 +1,109 @@
+"""Quick API test script to verify the multi-session architecture."""
+
+import httpx
+
+BASE_URL = "http://localhost:8000"
+
+def test_api():
+ """Test the basic API flow."""
+ print("Testing FastAPI Memory API...\n")
+
+ # Test user ID
+ user_id = "test-user-123"
+
+ # 1. Get user sessions (should be empty initially)
+ print(f"1. Fetching sessions for user: {user_id}")
+ response = httpx.get(f"{BASE_URL}/users/{user_id}/sessions")
+ print(f" Status: {response.status_code}")
+ print(f" Response: {response.json()}\n")
+
+ # 2. Create a new session
+ print("2. Creating new session...")
+ response = httpx.post(f"{BASE_URL}/users/{user_id}/sessions")
+ print(f" Status: {response.status_code}")
+ data = response.json()
+ print(f" Response: {data}")
+ session_id = data["session_id"]
+ print(f" Created session: {session_id}\n")
+
+ # 3. Send a chat message
+ print("3. Sending first chat message...")
+ response = httpx.post(
+ f"{BASE_URL}/chat",
+ json={
+ "message": "Hello, how are you?",
+ "user_id": user_id,
+ "session_id": session_id
+ }
+ )
+ print(f" Status: {response.status_code}")
+ print(f" Response: {response.json()}\n")
+
+ # 3b. Send another message to build conversation
+ print("3b. Sending second chat message...")
+ response = httpx.post(
+ f"{BASE_URL}/chat",
+ json={
+ "message": "Tell me a joke",
+ "user_id": user_id,
+ "session_id": session_id
+ }
+ )
+ print(f" Status: {response.status_code}")
+ print(f" Response: {response.json()}\n")
+
+ # 3c. Get conversation history
+ print("3c. Fetching conversation history...")
+ response = httpx.get(f"{BASE_URL}/users/{user_id}/sessions/{session_id}/history")
+ print(f" Status: {response.status_code}")
+ history = response.json()
+ print(f" Number of messages: {len(history.get('messages', []))}")
+ for i, msg in enumerate(history.get("messages", []), 1):
+ role = msg.get("role")
+ content = msg.get("content", "")[:50] # Truncate for display
+ suggested = msg.get("suggested_questions")
+ print(f" Message {i} ({role}): {content}...")
+ if role == "assistant":
+ print(f" Suggested questions: {suggested}")
+ print()
+
+ # 4. Get user sessions (should have 1 session now)
+ print("4. Fetching sessions again...")
+ response = httpx.get(f"{BASE_URL}/users/{user_id}/sessions")
+ print(f" Status: {response.status_code}")
+ print(f" Response: {response.json()}\n")
+
+ # 5. Create another session
+ print("5. Creating second session...")
+ response = httpx.post(f"{BASE_URL}/users/{user_id}/sessions")
+ data = response.json()
+ session_id_2 = data["session_id"]
+ print(f" Created session: {session_id_2}\n")
+
+ # 6. Get user sessions (should have 2 sessions now)
+ print("6. Fetching sessions (should have 2)...")
+ response = httpx.get(f"{BASE_URL}/users/{user_id}/sessions")
+ print(f" Status: {response.status_code}")
+ print(f" Response: {response.json()}\n")
+
+ # 7. Delete first session
+ print(f"7. Deleting session {session_id}...")
+ response = httpx.delete(f"{BASE_URL}/users/{user_id}/sessions/{session_id}")
+ print(f" Status: {response.status_code}")
+ print(f" Response: {response.json()}\n")
+
+ # 8. Get user sessions (should have 1 session now)
+ print("8. Fetching sessions (should have 1)...")
+ response = httpx.get(f"{BASE_URL}/users/{user_id}/sessions")
+ print(f" Status: {response.status_code}")
+ print(f" Response: {response.json()}\n")
+
+ print("✅ All tests completed!")
+
+if __name__ == "__main__":
+ try:
+ test_api()
+ except httpx.ConnectError:
+ print("❌ Could not connect to server. Make sure it's running on http://localhost:8000")
+ except Exception as e:
+ print(f"❌ Error: {e}")
diff --git a/atomic-examples/mcp-agent/example-client/example_client/main_sse.py b/atomic-examples/mcp-agent/example-client/example_client/main_sse.py
index 7c8271b..8789b3e 100644
--- a/atomic-examples/mcp-agent/example-client/example_client/main_sse.py
+++ b/atomic-examples/mcp-agent/example-client/example_client/main_sse.py
@@ -26,11 +26,11 @@ class MCPConfig:
mcp_server_url: str = "http://localhost:6969"
- # NOTE: In contrast to other examples, we use gpt-5-mini and not gpt-4o-mini here.
+ # NOTE: In contrast to other examples, we use gpt-5.1 and not gpt-5-mini here.
# In my tests, gpt-5-mini was not smart enough to deal with multiple tools like that
# and at the moment MCP does not yet allow for adding sufficient metadata to
# clarify tools even more and introduce more constraints.
- openai_model: str = "gpt-5-mini"
+ openai_model: str = "gpt-5.1"
openai_api_key: str = os.getenv("OPENAI_API_KEY")
reasoning_effort: str = "low"
diff --git a/atomic-examples/mcp-agent/example-client/example_client/main_stdio_async.py b/atomic-examples/mcp-agent/example-client/example_client/main_stdio_async.py
index 43093f5..2c6eab9 100644
--- a/atomic-examples/mcp-agent/example-client/example_client/main_stdio_async.py
+++ b/atomic-examples/mcp-agent/example-client/example_client/main_stdio_async.py
@@ -28,11 +28,11 @@ from mcp.client.stdio import stdio_client
class MCPConfig:
"""Configuration for the MCP Agent system using STDIO transport."""
- # NOTE: In contrast to other examples, we use gpt-5-mini and not gpt-4o-mini here.
+ # NOTE: In contrast to other examples, we use gpt-5.1 and not gpt-5-mini here.
# In my tests, gpt-5-mini was not smart enough to deal with multiple tools like that
# and at the moment MCP does not yet allow for adding sufficient metadata to
# clarify tools even more and introduce more constraints.
- openai_model: str = "gpt-5-mini"
+ openai_model: str = "gpt-5.1"
openai_api_key: str = os.getenv("OPENAI_API_KEY")
reasoning_effort: str = "low"
diff --git a/build_and_deploy.ps1 b/build_and_deploy.ps1
new file mode 100644
index 0000000..b504888
--- /dev/null
+++ b/build_and_deploy.ps1
@@ -0,0 +1,216 @@
+# Function to update version in a file
+function Update-VersionInFile {
+ param (
+ [string]$Version,
+ [string]$FilePath,
+ [bool]$DryRun = $false
+ )
+ # Read the file content
+ $content = Get-Content $FilePath
+ $updated = $false
+ $oldVersion = ""
+
+ # Process each line to only update the main package version in [tool.poetry] section
+ $inPoetrySection = $false
+ for ($i = 0; $i -lt $content.Length; $i++) {
+ $line = $content[$i]
+
+ # Check if we're entering the [tool.poetry] section
+ if ($line -match '^\[tool\.poetry\]') {
+ $inPoetrySection = $true
+ }
+ # Check if we're entering a different section
+ elseif ($line -match '^\[.*\]' -and $line -notmatch '^\[tool\.poetry\]') {
+ $inPoetrySection = $false
+ }
+ # Update version only if we're in the [tool.poetry] section and it's the main version line
+ elseif ($inPoetrySection -and $line -match '^version = "(.+)"$') {
+ $oldVersion = $matches[1]
+ if (-not $DryRun) {
+ $content[$i] = $line -replace 'version = ".*"', "version = `"$Version`""
+ }
+ $updated = $true
+ break
+ }
+ }
+
+ if ($updated) {
+ if ($DryRun) {
+ Write-Host "[DRY RUN] Would update main package version in $FilePath from $oldVersion to $Version"
+ } else {
+ Set-Content $FilePath $content
+ Write-Host "Updated main package version in $FilePath to $Version"
+ }
+ } else {
+ Write-Host "Warning: Could not find main package version to update in $FilePath"
+ }
+}
+
+# Function to update (increment) version
+function Update-Version {
+ param (
+ [string]$Version,
+ [string]$ReleaseType
+ )
+
+ $versionParts = $Version -split '\.'
+ $major = [int]$versionParts[0]
+ $minor = [int]$versionParts[1]
+ $patch = [int]$versionParts[2]
+
+ switch ($ReleaseType) {
+ "major" {
+ $major++
+ $minor = 0
+ $patch = 0
+ }
+ "minor" {
+ $minor++
+ $patch = 0
+ }
+ "patch" {
+ $patch++
+ }
+ default {
+ Write-Host "Invalid release type. Use 'major', 'minor', or 'patch'."
+ exit 1
+ }
+ }
+
+ return "$major.$minor.$patch"
+}
+
+# Function to set PyPI token
+function Set-PyPIToken {
+ param (
+ [bool]$DryRun = $false
+ )
+ if (-not $env:PYPI_TOKEN) {
+ Write-Host "Error: PYPI_TOKEN environment variable is not set."
+ if (-not $DryRun) {
+ exit 1
+ }
+ }
+ if ($DryRun) {
+ Write-Host "[DRY RUN] Would configure PyPI token"
+ } else {
+ poetry config pypi-token.pypi $env:PYPI_TOKEN
+ Write-Host "PyPI token configured successfully."
+ }
+}
+
+# Add this function at the beginning of the script
+function Import-EnvFile {
+ $envFile = ".env"
+ if (Test-Path $envFile) {
+ Get-Content $envFile | ForEach-Object {
+ if ($_ -match '^([^=]+)=(.*)$') {
+ $name = $matches[1]
+ $value = $matches[2]
+ Set-Item -Path "env:$name" -Value $value
+ }
+ }
+ Write-Host "Environment variables loaded from .env file."
+ }
+ else {
+ Write-Host "Warning: .env file not found."
+ }
+}
+
+# Call this function before any other operations in the script
+Import-EnvFile
+
+# Parse arguments
+$releaseType = ""
+$dryRun = $false
+
+foreach ($arg in $args) {
+ if ($arg -eq "--dry" -or $arg -eq "--dry-run") {
+ $dryRun = $true
+ }
+ elseif ($arg -in @("major", "minor", "patch")) {
+ $releaseType = $arg
+ }
+ else {
+ Write-Host "Unknown argument: $arg"
+ Write-Host "Usage: .\build_and_deploy.ps1 <major|minor|patch> [--dry]"
+ exit 1
+ }
+}
+
+# Check if release type is provided
+if (-not $releaseType) {
+ Write-Host "Please specify a release type (major, minor, or patch)"
+ Write-Host "Usage: .\build_and_deploy.ps1 <major|minor|patch> [--dry]"
+ exit 1
+}
+
+# Validate release type
+if ($releaseType -notin @("major", "minor", "patch")) {
+ Write-Host "Invalid release type. Use 'major', 'minor', or 'patch'."
+ exit 1
+}
+
+# Get current version from pyproject.toml (specifically from [tool.poetry] section)
+$pyprojectContent = Get-Content "pyproject.toml"
+$currentVersion = ""
+$inPoetrySection = $false
+
+foreach ($line in $pyprojectContent) {
+ if ($line -match '^\[tool\.poetry\]') {
+ $inPoetrySection = $true
+ }
+ elseif ($line -match '^\[.*\]' -and $line -notmatch '^\[tool\.poetry\]') {
+ $inPoetrySection = $false
+ }
+ elseif ($inPoetrySection -and $line -match '^version = "(.+)"$') {
+ $currentVersion = $matches[1]
+ break
+ }
+}
+
+if (-not $currentVersion) {
+ Write-Host "Error: Could not find current version in pyproject.toml [tool.poetry] section"
+ exit 1
+}
+
+# Calculate new version
+$newVersion = Update-Version -Version $currentVersion -ReleaseType $releaseType
+
+if ($dryRun) {
+ Write-Host "[DRY RUN] Would update version from $currentVersion to $newVersion"
+} else {
+ Write-Host "Updating version from $currentVersion to $newVersion"
+}
+
+# Update version in files
+Update-VersionInFile -Version $newVersion -FilePath "pyproject.toml" -DryRun $dryRun
+
+if ($dryRun) {
+ Write-Host "[DRY RUN] Would perform the following actions:"
+ Write-Host "[DRY RUN] - Build consolidated atomic-agents package"
+ Write-Host "[DRY RUN] - Install dependencies with poetry install"
+ Write-Host "[DRY RUN] - Build package with poetry build"
+ Write-Host "[DRY RUN] - Configure PyPI token"
+ Write-Host "[DRY RUN] - Upload to PyPI with poetry publish"
+ Write-Host "[DRY RUN] Dry run completed - no actual changes made!"
+ exit 0
+}
+
+# Build the consolidated package
+Write-Host "Building consolidated atomic-agents package..."
+
+# Create a new virtualenv in the project directory and install dependencies
+poetry install
+
+# Build the package
+poetry build
+
+# Before publishing, set the PyPI token
+Set-PyPIToken -DryRun $dryRun
+
+# Upload to PyPI
+Write-Host "Uploading atomic-agents to PyPI..."
+poetry publish
+
+Write-Host "Build and deploy process completed successfully!"
diff --git a/docs/examples/mcp_agent.md b/docs/examples/mcp_agent.md
index 537b1e7..4fa20c1 100644
--- a/docs/examples/mcp_agent.md
+++ b/docs/examples/mcp_agent.md
@@ -405,7 +405,7 @@ The client uses a configuration class:
@dataclass
class MCPConfig:
mcp_server_url: str = "http://localhost:6969"
- openai_model: str = "gpt-4o-mini"
+ openai_model: str = "gpt-5-mini"
openai_api_key: str = os.getenv("OPENAI_API_KEY")
```
@@ -413,7 +413,7 @@ For STDIO transport, additional options are available:
```python
@dataclass
class MCPConfig:
- openai_model: str = "gpt-4o-mini"
+ openai_model: str = "gpt-5-mini"
openai_api_key: str = os.getenv("OPENAI_API_KEY")
mcp_stdio_server_command: str = "poetry run example-mcp-server --mode stdio"
```
diff --git a/docs/guides/quickstart.md b/docs/guides/quickstart.md
index 5e5e9fe..afd2949 100644
--- a/docs/guides/quickstart.md
+++ b/docs/guides/quickstart.md
@@ -44,7 +44,7 @@ client = instructor.from_openai(openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"
agent = AtomicAgent[BasicChatInputSchema, BasicChatOutputSchema](
config=AgentConfig(
client=client,
- model="gpt-4o-mini", # Using the latest model
+ model="gpt-5-mini", # Using the latest model
history=history,
model_api_parameters={"max_tokens": 2048}
)
@@ -100,7 +100,7 @@ client = instructor.from_openai(openai.AsyncOpenAI(api_key=os.getenv("OPENAI_API
agent = AtomicAgent(
config=AgentConfig(
client=client,
- model="gpt-4o-mini",
+ model="gpt-5-mini",
history=history,
)
)
@@ -205,7 +205,7 @@ system_prompt_generator = SystemPromptGenerator(
agent = AtomicAgent[BasicChatInputSchema, CustomOutputSchema](
config=AgentConfig(
client=client,
- model="gpt-4o-mini",
+ model="gpt-5-mini",
system_prompt_generator=system_prompt_generator,
history=history,
)
@@ -240,7 +240,7 @@ The framework supports multiple AI providers:
```json
{
- "openai": "gpt-4o-mini",
+ "openai": "gpt-5-mini",
"anthropic": "claude-3-5-haiku-20241022",
"groq": "mixtral-8x7b-32768",
"ollama": "llama3",
@@ -278,7 +278,7 @@ def setup_client(provider):
from openai import OpenAI
api_key = os.getenv("OPENAI_API_KEY")
client = instructor.from_openai(OpenAI(api_key=api_key))
- model = "gpt-4o-mini"
+ model = "gpt-5-mini"
elif provider == "anthropic":
from anthropic import Anthropic
diff --git a/docs/index.md b/docs/index.md
index bd37bfd..df5bbd4 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -94,7 +94,7 @@ client = instructor.from_openai(openai.OpenAI()) # Pass your API key here if no
agent = AtomicAgent[BasicChatInputSchema, BasicChatOutputSchema](
config=AgentConfig(
client=client,
- model="gpt-4o-mini", # Use your provider's model
+ model="gpt-5-mini", # Use your provider's model
history=history
)
)