Update readme and add setup to run-dojo

Author: Rana Umar Majeed

apps/dojo/scripts/prep-dojo-everything.js

@@ -97,6 +97,11 @@ const ALL_TARGETS = {
     name: "Pydantic AI",
     cwd: path.join(integrationsRoot, "pydantic-ai/python/examples"),
   },
+  "aws-strands": {
+    command: "poetry install",
+    name: "AWS Strands",
+    cwd: path.join(integrationsRoot, "aws-strands/python/examples"),
+  },
   "adk-middleware": {
     command: "uv sync",
     name: "ADK Middleware",

apps/dojo/scripts/run-dojo-everything.js

@@ -111,6 +111,12 @@ const ALL_SERVICES = {
     cwd: path.join(integrationsRoot, 'pydantic-ai/python/examples'),
     env: { PORT: 8009 },
   }],
+  'aws-strands': [{
+    command: 'poetry run dev',
+    name: 'AWS Strands',
+    cwd: path.join(integrationsRoot, 'aws-strands/python/examples'),
+    env: { PORT: 8017 },
+  }],
   'adk-middleware': [{
     command: 'uv run dev',
     name: 'ADK Middleware',
@@ -174,6 +180,7 @@ const ALL_SERVICES = {
       A2A_MIDDLEWARE_FINANCE_URL: 'http://localhost:8012',
       A2A_MIDDLEWARE_IT_URL: 'http://localhost:8013',
       A2A_MIDDLEWARE_ORCHESTRATOR_URL: 'http://localhost:8014',
+      AWS_STRANDS_URL: 'http://localhost:8017',
       NEXT_PUBLIC_CUSTOM_DOMAIN_TITLE: 'cpkdojo.local___CopilotKit Feature Viewer',
     },
   }],

integrations/aws-strands/python/examples/README.md

@@ -1,69 +1,82 @@
-# Strands Integration (OpenAI)
+# AWS Strands Example Server
 
-This integration demonstrates how to use Strands Agents SDK with OpenAI models and AG-UI protocol.
+Demo FastAPI server that wires the Strands Agents SDK (Gemini models) into the
+AG-UI protocol. Each route mounts a ready-made agent that showcases different UI
+patterns (vanilla chat, backend tool rendering, shared state, and generative UI).
 
-## Prerequisites
+## Requirements
 
-- Python 3.12 or later
-- Poetry for dependency management
-- OpenAI API key
-- Strands Agents SDK with OpenAI support installed
+- Python 3.12 or 3.13 (the project is pinned to `<3.14`)
+- Poetry 1.8+ (ships with the repo via `curl -sSL https://install.python-poetry.org | python3 -`)
+- Google API key with access to Gemini 2.5 Flash (set as `GOOGLE_API_KEY`)
+- (Optional) AG-UI repo running locally so you can point the Dojo at these routes
 
-## Setup
+## Quick start
 
-1. Install Strands SDK with OpenAI support:
 ```bash
-pip install 'strands-agents[openai]'
+cd integrations/aws-strands/python/examples
+
+# pick a supported interpreter if your global default is 3.14
+poetry env use python3.13
+
+poetry install
 ```
 
-2. Configure OpenAI API key:
+Create a `.env` file in this folder (same dir as `pyproject.toml`) so every
+example can load credentials automatically:
+
 ```bash
-# Set your OpenAI API key (required)
-export OPENAI_API_KEY=your-api-key-here
+GOOGLE_API_KEY=your-gemini-key
+# Optional overrides
+PORT=8000                 # FastAPI listen port
 ```
 
-3. Optional: Configure OpenAI model settings:
-```bash
-# Set the OpenAI model to use (default: gpt-4o)
-export OPENAI_MODEL=gpt-4o
+> The sample agents default to `gemini-2.5-flash` and already set sensible
+> temperature/token parameters; override only if you need a different tier.
 
-# Set max tokens (default: 2000)
-export OPENAI_MAX_TOKENS=2000
+## Running the demo server
 
-# Set temperature (default: 0.7)
-export OPENAI_TEMPERATURE=0.7
-```
+Either command exposes all mounted apps on `http://localhost:${PORT:-8000}`:
 
-4. Install dependencies:
 ```bash
-cd integrations/aws-strands-integration/python/examples
-poetry install
+poetry run dev          # uses the Poetry script entry point (server:main)
+# or
+poetry run python -m server
 ```
 
-## Running the server
+The root route lists the available demos:
 
-To run the server:
+| Route | Description |
+| --- | --- |
+| `/agentic-chat` | Simple chat agent with a frontend-only `change_background` tool |
+| `/backend-tool-rendering` | Backend-executed tools (charts, faux weather) rendered in AG-UI |
+| `/agentic-generative-ui` | Demonstrates `PredictState` + delta streaming for plan tracking |
+| `/shared-state` | Recipe builder showing shared JSON state + tool arguments |
 
-```bash
-cd integrations/aws-strands-integration/python/examples
+Point the AG-UI Dojo (or any AG-UI client) at these SSE endpoints to see the
+Strands wrapper translate Gemini events into protocol-native messages.
 
-poetry install && poetry run dev
-```
+## Environment reference
+
+| Variable | Required | Purpose |
+| --- | --- | --- |
+| `GOOGLE_API_KEY` | Yes | Auth for the Gemini SDK (`strands.models.gemini.GeminiModel`) |
+| `PORT` | No | Overrides the default `8000` uvicorn port |
 
-The server will start on `http://localhost:8000` by default. You can change the port by setting the `PORT` environment variable.
+All OpenTelemetry exporters are disabled by default in code (`OTEL_SDK_DISABLED`
+and `OTEL_PYTHON_DISABLED_INSTRUMENTATIONS`), so you do not need to set those
+manually.
 
-## Integration Details
+## How it works
 
-This integration uses the Strands Agents SDK with OpenAI models. The server:
-- Accepts AG-UI protocol requests
-- Connects to OpenAI models via Strands SDK
-- Streams responses back as AG-UI events
-- Handles tool calls and state management
+- Each `server/api/*.py` file constructs a Strands `Agent`, registers any tools,
+  and wraps it with `ag_ui_strands.StrandsAgent`.
+- `server/__init__.py` mounts the four FastAPI apps under a single router and
+  exposes the `main()` entrypoint that `poetry run dev` calls.
+- The project depends on `ag_ui_strands` via a path dependency (`..`) so you can
+  develop the integration and server side-by-side without publishing a wheel.
+- Want a different Gemini tier? Update the `model_id` argument in the agent
+  definitions inside `server/api/*.py`.
 
-## Notes
 
-- The integration uses OpenAI models (default: gpt-4o)
-- Ensure your OpenAI API key is valid and has access to the specified model
-- The integration supports streaming responses when available in the Strands SDK
-- You can customize the model, max_tokens, and temperature via environment variables
 

integrations/aws-strands/python/examples/pyproject.toml

@@ -4,7 +4,7 @@ version = "0.1.0"
 description = "Strands integration server for AG-UI using OpenAI models"
 authors = ["AG-UI Contributors"]
 readme = "README.md"
-package-mode = false
+packages = [{ include = "server" }]
 
 [tool.poetry.dependencies]
 python = "<3.14,>=3.12"
@@ -20,4 +20,4 @@ requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
 
 [tool.poetry.scripts]
-dev = "aws_strands_server:main"
+dev = "server:main"