Multi-armed bandit agent testing platform with FastAPI backend and Next.js frontend.

• Backend: FastAPI (Python 3.11+)
• Frontend: Next.js 15 with TypeScript
• Styling: Tailwind CSS
• Experiment Tracking: Weave
• Cache: Redis (optional)

agent-playground/
├── backend/
│   ├── app/
│   │   ├── __init__.py
│   │   └── main.py          # FastAPI application
│   ├── requirements.txt
│   └── Dockerfile
├── frontend/
│   ├── src/
│   │   ├── app/             # Next.js app directory
│   │   ├── components/      # React components
│   │   └── lib/             # Utilities and API client
│   ├── package.json
│   ├── next.config.js
│   ├── tsconfig.json
│   └── Dockerfile
├── docker-compose.yml
├── package.json             # Root package.json for managing both services
└── README.md

• Python 3.11 or higher
• Node.js 20 or higher
• Docker and Docker Compose (optional, for containerized deployment)

1. Clone the repository

   cd agent-playground

2. Install dependencies

   # Install root dependencies (concurrently for running both services)
   npm install
   
   # Install backend dependencies
   cd backend
   pip install -r requirements.txt
   cd ..
   
   # Install frontend dependencies
   cd frontend
   npm install
   cd ..

3. Set up environment variables

   cp .env.example .env
   # Edit .env with your configuration

4. Run the development servers

   Run them separately in different terminals:

   Terminal 1: Backend

   cd backend
   python -m uvicorn app.main:app --reload --host 0.0.0.0 --port 8000

   Terminal 2: Frontend

   cd frontend
   npm run dev

5. Access the application

   • Frontend: http://localhost:3000
   • Backend API: http://localhost:8000
   • API Documentation: http://localhost:8000/docs

1. Build and start all services

   docker-compose up --build

2. Access the application

   • Frontend: http://localhost:3000
   • Backend API: http://localhost:8000
   • Redis: localhost:6379

3. Stop all services

   docker-compose down

• npm run dev - Run both frontend and backend in development mode
• npm run dev:frontend - Run only frontend
• npm run dev:backend - Run only backend
• npm run install - Install all dependencies
• npm run docker:up - Start Docker containers
• npm run docker:down - Stop Docker containers

Run backend server:

cd backend
python -m uvicorn app.main:app --reload --host 0.0.0.0 --port 8000

Other commands:

• pip install -r requirements.txt - Install Python dependencies

• npm run dev - Run development server
• npm run build - Build for production
• npm run start - Start production server
• npm run lint - Run ESLint

• GET / - Root endpoint
• GET /health - Health check
• GET /docs - Interactive API documentation (Swagger UI)
• GET /redoc - Alternative API documentation (ReDoc)

• GET /api/v1/hello - Hello world endpoint

1. Add routes in backend/app/main.py
2. Define request/response models using Pydantic
3. Update frontend API client in frontend/src/lib/api.ts

1. Create new files in frontend/src/app/ directory
2. Use the App Router file conventions (page.tsx, layout.tsx)
3. Add API calls using the client in frontend/src/lib/api.ts

The backend is configured to initialize Weave for experiment tracking. To use it:

1. Set your WANDB_API_KEY in .env
2. Weave will automatically track experiments
3. View results at https://wandb.ai/

If you get a "port already in use" error:

# Find and kill the process using the port
lsof -ti:8000 | xargs kill -9  # Backend
lsof -ti:3000 | xargs kill -9  # Frontend

cd backend
pip install --upgrade pip
pip install -r requirements.txt

cd frontend
rm -rf node_modules package-lock.json
npm install

MIT

1. Create a feature branch
2. Make your changes
3. Test thoroughly
4. Submit a pull request

Total Integration Score: 7/7 (100%)