Building AI agents, atomically
Update model names, finish FastAPI implementation
KennyVaneetvelde398d5c655365
diff --git a/README.md b/README.mdindex 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.mdindex 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 configoutput_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 hereoutput_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 parametersconfig = BaseAgentConfig(client=client,- model="gpt-4o-mini",+ model="gpt-5-mini",memory=AgentMemory(), # Old field nametemperature=0.7, # Direct parametermax_tokens=1000 # Direct parameter@@ -294,7 +294,7 @@ agent = AtomicAgent[CustomInputSchema, CustomOutputSchema](# NEW - Grouped parametersconfig = AgentConfig(client=client,- model="gpt-4o-mini",+ model="gpt-5-mini",history=ChatHistory(), # New field namemodel_api_parameters={ # Temperature and max_tokens moved here"temperature": 0.7,@@ -347,7 +347,7 @@ from atomic_agents.context import ChatHistoryclient = 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 asyncioclient = 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 parametersAgentConfig(client=client,- model="gpt-4o-mini",+ model="gpt-5-mini",history=history, # Changed from memorysystem_prompt_generator=system_prompt,# No input_schema or output_schema in configdiff --git a/agents.md b/agents.mdindex 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 agentdiff --git a/atomic-agents/atomic_agents/agents/atomic_agent.py b/atomic-agents/atomic_agents/agents/atomic_agent.pyindex 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 chatdiff --git a/atomic-agents/tests/agents/test_atomic_agent.py b/atomic-agents/tests/agents/test_atomic_agent.pyindex 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_historyassert agent.system_prompt_generator == mock_system_prompt_generatorassert "max_tokens" not in agent.model_api_parameters@@ -114,7 +114,7 @@ def test_initialization(agent, mock_instructor, mock_history, mock_system_promptdef 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, mockdef 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_sdef 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_histodef 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_paramconfig = 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 Noneconfig = 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_historconfig = 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 workassert agent.client == mock_instructor- assert agent.model == "gpt-4o-mini"+ assert agent.model == "gpt-5-mini"assert agent.history == mock_historyassert agent.system_prompt_generator == mock_system_prompt_generatordiff --git a/atomic-examples/fastapi-memory/README.md b/atomic-examples/fastapi-memory/README.mdindex 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:```bashpoetry 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:```bashcurl -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 Examplesdiff --git a/atomic-examples/fastapi-memory/fastapi_memory/__init__.py b/atomic-examples/fastapi-memory/fastapi_memory/__init__.pynew file mode 100644index 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.pynew file mode 100644index 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__.pynew file mode 100644index 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__.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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 = 3diff --git a/atomic-examples/fastapi-memory/fastapi_memory/lib/schemas.py b/atomic-examples/fastapi-memory/fastapi_memory/lib/schemas.pynew file mode 100644index 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.pyindex 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 uuidfrom 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 AtomicAgentfrom 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]@asynccontextmanagerasync def lifespan(app: FastAPI):+ """Application lifespan manager to clean up resources on shutdown.++ Args:+ app: FastAPI application instance++ Yields:+ None+ """yieldsessions.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.lockindex 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.tomlindex 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.pynew file mode 100644index 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.pyindex 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.pyindex 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_clientclass 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.ps1new file mode 100644index 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.mdindex 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:@dataclassclass 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@dataclassclass 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.mdindex 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 modelhistory=history,model_api_parameters={"max_tokens": 2048})@@ -100,7 +100,7 @@ client = instructor.from_openai(openai.AsyncOpenAI(api_key=os.getenv("OPENAI_APIagent = 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 OpenAIapi_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 Anthropicdiff --git a/docs/index.md b/docs/index.mdindex 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 noagent = AtomicAgent[BasicChatInputSchema, BasicChatOutputSchema](config=AgentConfig(client=client,- model="gpt-4o-mini", # Use your provider's model+ model="gpt-5-mini", # Use your provider's modelhistory=history))