Merge branch 'main' of https://github.com/ag2ai/artifacts

Author: SirEntropy

.github/workflows/generate-registry.yml

@@ -13,6 +13,8 @@ jobs:
       contents: write
     steps:
       - uses: actions/checkout@v4
+        with:
+          token: ${{secrets.REGISTRY_PAT}}
 
       - uses: actions/setup-python@v5
         with:

registry.json

@@ -1,6 +1,6 @@
 {
   "version": "1",
-  "updated": "2026-03-19T04:23:44Z",
+  "updated": "2026-03-19T04:42:42Z",
   "artifacts": [
     {
       "name": "ag2",

templates/fullstack-multi-agent/artifact.json

@@ -0,0 +1,30 @@
+{
+  "name": "fullstack-multi-agent",
+  "type": "template",
+  "display_name": "Full-Stack Multi-Agent App",
+  "description": "A full-stack application with a FastAPI backend orchestrating an AG2 multi-agent team and a React + Vite frontend with real-time chat UI",
+  "version": "1.0.0",
+  "authors": ["ag2ai"],
+  "license": "Apache-2.0",
+  "tags": ["fullstack", "react", "fastapi", "multi-agent", "websocket", "chat"],
+  "template": {
+    "scaffold": "scaffold/",
+    "variables": {
+      "project_name": {
+        "prompt": "Project name",
+        "default": "my-agent-app",
+        "transform": "slug"
+      },
+      "description": {
+        "prompt": "Project description",
+        "default": "A full-stack multi-agent application"
+      }
+    },
+    "ignore": ["__pycache__", "*.pyc", ".git", "node_modules"],
+    "post_install": []
+  },
+  "skills": {
+    "dir": "skills/",
+    "auto_install": true
+  }
+}

templates/fullstack-multi-agent/scaffold/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.py[cod]
+.env
+.venv/
+dist/
+*.egg-info/
+.pytest_cache/
+node_modules/

templates/fullstack-multi-agent/scaffold/README.md.tmpl

@@ -0,0 +1,49 @@
+# {{ project_name }}
+
+{{ description }}
+
+A full-stack application with an AG2 multi-agent backend (FastAPI + WebSocket) and a React frontend.
+
+## Architecture
+
+```
+{{ project_name }}/
+├── backend/          # FastAPI + AG2 multi-agent team
+│   ├── app/
+│   │   ├── main.py       # FastAPI app, REST + WebSocket endpoints
+│   │   ├── agents.py     # AG2 agent team: planner, coder, reviewer
+│   │   └── schemas.py    # Pydantic request/response models
+│   └── tests/
+├── frontend/         # React + Vite + TypeScript
+│   └── src/
+│       ├── App.tsx
+│       └── components/
+│           └── Chat.tsx  # WebSocket chat interface
+```
+
+## Quick start
+
+```bash
+# Backend
+cd backend
+uv sync
+cp .env.example .env   # add your API keys
+uv run uvicorn app.main:app --reload
+
+# Frontend (separate terminal)
+cd frontend
+npm install
+npm run dev
+```
+
+Open http://localhost:5173 — the chat UI connects to the backend WebSocket at ws://localhost:8000/ws/chat.
+
+## How it works
+
+1. User sends a message through the React chat UI
+2. The frontend opens a WebSocket connection to the backend
+3. FastAPI hands the message to an AG2 multi-agent team:
+   - **Planner** — breaks the request into steps
+   - **Coder** — implements the solution
+   - **Reviewer** — checks for correctness and suggests improvements
+4. Each agent response is streamed back to the frontend in real time

templates/fullstack-multi-agent/scaffold/backend/.env.example

@@ -0,0 +1,4 @@
+# LLM provider API keys — uncomment the one you use
+# OPENAI_API_KEY=sk-...
+# ANTHROPIC_API_KEY=sk-ant-...
+# GEMINI_API_KEY=...

templates/fullstack-multi-agent/scaffold/backend/app/__init__.py

@@ -0,0 +1,68 @@
+"""AG2 multi-agent team: planner, coder, reviewer.
+
+The team uses a RoundRobin pattern so each agent contributes in sequence.
+Agent responses are collected via a callback and returned to the caller.
+"""
+
+from __future__ import annotations
+
+from autogen import AssistantAgent, LLMConfig
+from autogen.agentchat.group import run_group_chat
+from autogen.agentchat.group.patterns.pattern import RoundRobinPattern
+
+config = LLMConfig(api_type="openai", model="gpt-4o")
+
+with config:
+    planner = AssistantAgent(
+        name="planner",
+        system_message=(
+            "You are a planning agent. Given a user request, break it into clear, "
+            "numbered steps. Be specific about what needs to happen at each step. "
+            "Do not write code — only produce the plan."
+        ),
+    )
+
+    coder = AssistantAgent(
+        name="coder",
+        system_message=(
+            "You are a coding agent. Given a plan from the planner, implement "
+            "the solution step by step. Write clean, well-documented code. "
+            "If something is ambiguous, state your assumption and proceed."
+        ),
+    )
+
+    reviewer = AssistantAgent(
+        name="reviewer",
+        system_message=(
+            "You are a code review agent. Review the coder's implementation for "
+            "correctness, edge cases, security issues, and clarity. Provide "
+            "specific, actionable feedback. If the code is good, say so briefly."
+        ),
+    )
+
+AGENTS = [planner, coder, reviewer]
+AGENT_NAMES = [a.name for a in AGENTS]
+
+pattern = RoundRobinPattern(
+    initial_agent=planner,
+    agents=AGENTS,
+)
+
+
+async def run_team(message: str) -> list[dict[str, str]]:
+    """Run the multi-agent team on a user message.
+
+    Returns a list of {"agent": name, "content": text} dicts.
+    """
+    result = await run_group_chat(
+        pattern=pattern,
+        messages=message,
+        max_rounds=6,
+    )
+
+    messages: list[dict[str, str]] = []
+    for msg in result.messages:
+        if hasattr(msg, "source") and hasattr(msg, "content") and msg.content:
+            messages.append({"agent": msg.source, "content": msg.content})
+
+    return messages

templates/fullstack-multi-agent/scaffold/backend/app/agents.py

@@ -0,0 +1,87 @@
+"""FastAPI application with REST and WebSocket endpoints.
+
+Run with:
+    uvicorn app.main:app --reload
+"""
+
+from __future__ import annotations
+
+import json
+import traceback
+
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi.middleware.cors import CORSMiddleware
+
+from .agents import AGENT_NAMES, run_team
+from .schemas import AgentMessage, HealthResponse
+
+app = FastAPI(title="{{ project_name }}", description="{{ description }}")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:5173"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/api/health", response_model=HealthResponse)
+async def health() -> HealthResponse:
+    """Health check — returns status and available agent names."""
+    return HealthResponse(status="ok", agents=AGENT_NAMES)
+
+
+@app.websocket("/ws/chat")
+async def chat_ws(websocket: WebSocket) -> None:
+    """WebSocket endpoint for real-time multi-agent chat.
+
+    Protocol:
+        Client sends: {"message": "user text"}
+        Server sends: {"agent": "name", "content": "...", "type": "agent_message"}
+        Server sends: {"agent": "", "content": "", "type": "done"} when finished
+    """
+    await websocket.accept()
+
+    try:
+        while True:
+            data = await websocket.receive_text()
+            payload = json.loads(data)
+            user_message = payload.get("message", "")
+
+            if not user_message:
+                await websocket.send_text(
+                    AgentMessage(agent="system", content="Empty message", type="error").model_dump_json()
+                )
+                continue
+
+            # Notify client that processing has started
+            await websocket.send_text(
+                AgentMessage(agent="system", content="Agents are working...", type="status").model_dump_json()
+            )
+
+            # Run the agent team
+            try:
+                responses = await run_team(user_message)
+            except Exception:
+                await websocket.send_text(
+                    AgentMessage(
+                        agent="system",
+                        content=f"Agent error: {traceback.format_exc()}",
+                        type="error",
+                    ).model_dump_json()
+                )
+                continue
+
+            # Stream each agent response
+            for resp in responses:
+                msg = AgentMessage(agent=resp["agent"], content=resp["content"])
+                await websocket.send_text(msg.model_dump_json())
+
+            # Signal completion
+            await websocket.send_text(
+                AgentMessage(agent="", content="", type="done").model_dump_json()
+            )
+
+    except WebSocketDisconnect:
+        pass

templates/fullstack-multi-agent/scaffold/backend/app/main.py

@@ -0,0 +1,24 @@
+"""Pydantic models for API request/response types."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class ChatRequest(BaseModel):
+    """Incoming chat message from the frontend."""
+
+    message: str
+
+
+class AgentMessage(BaseModel):
+    """A single message from an agent, sent over WebSocket."""
+
+    agent: str
+    content: str
+    type: str = "agent_message"  # agent_message | status | error | done
+
+
+class HealthResponse(BaseModel):
+    status: str = "ok"
+    agents: list[str] = []