Angular Material + FastAPI + LlamaIndex CLAUDE.md Template for Claude Code (CLAUDE.md template)

Overview

CLAUDE.md template is a copyable Claude Code blueprint for rapidly wiring up an Angular Material frontend with a FastAPI backend and a LlamaIndex powered semantic search layer. This page delivers a stack specific CLAUDE.md template for Angular Material + FastAPI + LlamaIndex and provides a ready to paste instruction block for Claude Code.

When to Use This CLAUDE.md Template

• You are building a production grade Angular Material UI paired with a FastAPI API backend
• You plan to add semantic search over data with LlamaIndex
• You want a repeatable Claude Code workflow to accelerate prototyping and onboarding

Copyable CLAUDE.md Template

# CLAUDE.md

Project role
- You are a full stack engineer who designs and implements an Angular Material frontend, a FastAPI backend, and a LlamaIndex powered search layer. You write Claude Code that is safe, maintainable, and production ready.

Architecture rules
- Monorepo with frontend and backend at project root
- Frontend built with Angular Material components; backend REST APIs consumed by frontend
- LlamaIndex index built in backend; index data stored in a local directory for dev and in object storage for prod
- Claude Code communicates over HTTPS; secrets not hardcoded

File structure rules
- Frontend: /frontend
  - src/app
  - src/environments
  - angular.json
  - tsconfig.json
  - package.json
- Backend: /backend
  - app/main.py
  - app/api/
  - app/models.py
  - requirements.txt
- LlamaIndex-specific
  - llama_index_config.json
  - data/llama_index/initial_data/

Authentication rules
- Use OAuth2 password flow with JWTs; access token short lived; refresh token stored in httpOnly cookie
- Backend validates tokens on protected endpoints

Database rules
- Development uses SQLite; production uses Postgres
- SQLAlchemy models to map to tables; Alembic migrations

Validation rules
- Pydantic models for request and response
- Input data sanitized; all endpoints reject invalid payloads with clear errors

Security rules
- HTTPS enforced; CORS configured for frontend domain
- CSRF protection for web UI; no secret exposure in code

Testing rules
- Unit tests for frontend components (Angular TestBed) and backend endpoints (pytest)
- Tests cover authentication, data validation, and search indexing

Deployment rules
- Dockerized monorepo with Dockerfile for frontend and backend
- docker-compose.yaml orchestrates frontend, backend, and a Postgres service
- CI runs tests and builds both services

Things Claude must not do
- Do not generate code that accesses local secrets or secrets in environment
- Do not create endpoints that allow arbitrary code execution
- Do not bypass authentication or ignore input validation
- Do not rely on deprecated libraries

Recommended Project Structure

angular-material-fastapi-llamaindex/
├── frontend/
│   ├── src/
│   │   ├── app/
│   │   │   ├── components/
│   │   │   └── pages/
│   │   └── index.html
│   ├── angular.json
│   └── package.json
├── backend/
│   ├── app/
│   │   ├── main.py
│   │   ├── api/
│   │   └── models.py
│   ├── requirements.txt
│   └── Dockerfile
├── llama_index_config.json
└── docker-compose.yaml

Core Engineering Principles

• Maintainable and well typed code with clear boundaries between frontend and backend
• Security by default with proper authentication and input validation
• Testability across unit and integration tests
• Performance conscious architecture for API latency and UI responsiveness

Code Construction Rules

• Frontend uses Angular Material; components must be accessible; use reactive forms
• Backend uses FastAPI; endpoints return strict Pydantic models
• Use LlamaIndex for semantic search; index built in backend on startup
• Claude Code should not access user secrets; pass them via environment or config

Security and Production Rules

• Enforce HTTPS; configure HSTS
• Use secure cookies for tokens; CSRF protection for UI
• Audit logging and error handling; avoid leaking stack traces in prod

Testing Checklist

• Frontend unit tests for components and services
• Backend tests for API endpoints and data validation
• End to end flow tests verify search results from UI to LlamaIndex

Common Mistakes to Avoid

• Skipping input validation or using permissive schemas
• Hardcoding secrets in code or config
• Overloading frontend with non accessible components

Related implementation resources: AI Use Case for Software Agencies Using Github Copilot To Accelerate Boilerplate Code Generation for New Client Mvps and How skill files guide dependency choices for production AI workflows.

FAQ

1. Q1 Is this CLAUDE.md template suitable for production? A1 Yes with proper environment configuration secrets management and CI/CD
2. Q2 Do I need a dedicated LlamaIndex instance? A2 Not necessarily you can run a local index and scale as needed
3. Q3 Can I customize the stack? A3 Yes adapt frontend components backend endpoints and index configuration as needed
4. Q4 How do I test semantic search? A4 Use unit tests for the index wrapper and integration tests for UI search results
5. Q5 Where do I store runtime config? A5 Use environment variables or a config service never hardcode values
6. Q6 How do I deploy? A6 Use Docker Compose in dev and Kubernetes or ECS in prod ensure TLS termination