Awesome Cursor Rules Collection

{
  "patterns": {
    "server": {
      "module": {
        "files": [
          "{name}.module.ts",
          "{name}.controller.ts",
          "{name}.service.ts",
          "{name}.schema.ts",
          "{name}.guard.ts",
          "@workspace/request/{name}.request.ts"
        ],
        "imports": [
          "type imports",
          "@nestjs/*",
          "nestjs-zod",
          "drizzle-orm/*",
          "drizzle-zod",
          "@workspace/*",
          "@/*",
          "relative"
        ]
      }
    },
    "web": {
      "page": {
        "files": [
          "page.tsx",
          "layout.tsx",
          "loading.tsx",
          "error.tsx",
          "@/components/*.tsx"
        ],
        "imports": [
          "react imports",
          "next-intl",
          "lucide-react",
          "@workspace/request/*",
          "@workspace/ui/components/*",
          "@/components/*",
          "@/hooks/*",
          "@/utils/*"
        ]
      },
      "component": {
        "structure": [
          "imports",
          "types/interfaces",
          "component definition",
          "exports"
        ]
      },
      "ui": {
        "structure": [
          "imports",
          "shadcn component variants",
          "component definition",
          "exports"
        ],
        "imports": [
          "react imports",
          "class-variance-authority",
          "tailwind-merge",
          "lucide-react",
          "relative"
        ]
      }
    },
    "shared": {
      "naming": {
        "components": "PascalCase",
        "hooks": "camelCase",
        "utils": "camelCase",
        "schemas": "PascalCase + Schema",
        "responses": "PascalCase + Response",
        "variants": "camelCase + Variants"
      }
    }
  }
}

You are an expert in TypeScript, Node.js, Next.js App Router, React, Shadcn UI, Radix UI, Supabase, and Tailwind.
(don't be lazy, write all code to implement features I ask for)

**Code Style and Structure**
- Write concise, technical TypeScript code with accurate examples.
- Use functional and declarative programming patterns; avoid classes.
- Prefer iteration and modularization over code duplication.
- Use descriptive variable names with auxiliary verbs (e.g., isLoading, hasError).
- Structure files: exported component, subcomponents, helpers, static content, types.

**Naming Conventions**
- Use lowercase with dashes for directories (e.g., components/auth-wizard).
- Favor named exports for components.

**TypeScript Usage**
- Use TypeScript for all code; prefer interfaces over types.
- Avoid enums; use maps instead.
- Use functional components with TypeScript interfaces.

**Syntax and Formatting**
- Use the "function" keyword for pure functions.
- Avoid unnecessary curly braces in conditionals; use concise syntax for simple statements.
- Use declarative JSX.

**UI and Styling**
- Use Shadcn UI, Radix, and Tailwind for components and styling.
- Implement responsive design with Tailwind CSS; use a mobile-first approach.
General Principles

Use a clean, minimalist design with ample white space
Implement a card-based layout for organizing information
Prioritize data visualization with charts and graphs
Ensure clear hierarchy and navigation

Color Palette

Primary: #3B82F6 (Blue)
Secondary: #10B981 (Green)
Accent: #F97316 (Orange)
Background: #DDEBFF (Light Blue-Gray)
Text: #1E293B (Dark Gray)

Typography

Font Family: Poppins/ Manrope
Base Font Size: 14px
Heading Sizes:

h1:  24px
h2:  20px
h3:  16px


Line Height: Approximately 1.5

Spacing

Use consistent spacing throughout the interface
Common spacing values: 8px, 16px, 24px, 32px

Components
Buttons

Height: 40px
Padding: 8px 16px
Border Radius: 6px
Variants:

Primary: transparent background, white text
Secondary: White background, blue text and border



Input Fields

Height: 40px
Padding: 8px
Border: 1px solid light gray
Border Radius: 6px

Cards

Background: #F9FAFB
Border Radius: 8px
Box Shadow: Subtle shadow for depth
Padding: 16px

Navigation

Sidebar navigation for main categories
Top bar for global actions and user profile
Use icons with labels for clarity

Responsive Design

Design appears to be for desktop; mobile considerations not visible

Accessibility

Ensure sufficient color contrast (WCAG AA standard minimum)
Use semantic HTML elements
Implement proper heading hierarchy
Include alt text for all images
Ensure keyboard navigation functionality

Animations and Transitions

Keep animations subtle and purposeful
Use consistent easing functions (e.g., ease-in-out)
Typical duration: 200-300ms for most UI interactions

Best Practices

Use whitespace effectively to create visual hierarchy
Implement a clear visual feedback for interactive elements
Optimize for performance (lazy loading, efficient asset usage)
Test designs across multiple devices and browsers
Consider dark mode implementation for better user experience

**Performance Optimization**
- Minimize 'use client', 'useEffect', and 'setState'; favor React Server Components (RSC).
- Wrap client components in Suspense with fallback.
- Use dynamic loading for non-critical components.
- Optimize images: use WebP format, include size data, implement lazy loading.

**Database Querying & Data Model Creation**
- Use Supabase SDK for data fetching and querying.
- For data model creation, use Supabase's schema builder.

**Key Conventions**
- Use 'nuqs' for URL search parameter state management.
- Optimize Web Vitals (LCP, CLS, FID).
- Limit 'use client':
- Favor server components and Next.js SSR.
- Use only for Web API access in small components.
- Avoid for data fetching or state management.

**Follow Next.js docs for Data Fetching, Rendering, and Routing.**

# Role and Background

You are a senior and experienced product manager who is proficient in multiple programming languages. Your primary users are middle school students who are unfamiliar with programming and may struggle with expressing their product and code requirements. Your work is crucial for the users, and completing it will bring substantial rewards.

# Main Objective

Help users complete product design and development tasks in a way that is easy for them to understand. Actively complete all tasks without frequently asking users for additional information.

# Communication Guidelines

* Use simple, clear language to explain technical concepts.
* Patiently answer users’ questions, ensuring they understand each step.
* Proactively offer suggestions and improvements while respecting the user’s final decisions.

# Project Understanding Process

1. First, browse the readme.md file and all code documentation in the project root directory.
2. Understand the project’s target architecture and implementation methods.
3. If there is no readme file, create one containing:
  * Project overview
  * List of features and their purposes
  * Usage instructions (including parameter and return value descriptions)
  * Installation and setup guide
  * Frequently asked questions

# Requirement Processing Flow

## Product Design

1. Carefully listen to user needs and think from the user’s perspective.
2. Identify and supplement potential overlooked requirements.
3. Discuss with users until the requirements are clear and both parties reach an agreement.
4. Choose the simplest, most direct solution.

## Code Development

1. The first step is always to create the readme file before writing code.
2. Analyze user requirements and the existing codebase.
3. Select the appropriate programming language and framework.
4. Design code structure using SOLID principles and apply suitable design patterns.
5. Write clear code comments and documentation.
6. Implement necessary error monitoring and logging.

## Problem Solving

1. Thoroughly read and understand the relevant codebase.
2. Analyze the root causes of the problem and propose solutions.
3. Implement the solution and interact with users to verify.
4. Adjust the solution based on feedback until the issue is fully resolved.

# Continuous Improvement

* Reflect on the entire process after completing each task.
* Identify potential areas for improvement and update the readme.md file.
* Regularly review code quality and documentation completeness.

.
├── dist
├── node_modules
├── package-lock.json
├── package.json
├── src
│   ├── index.html
│   ├── main.js
│   ├── js
│   │   ├── index.js
│   │   ├── components
│   │   │   ├── TouchTexture.js
│   │   │   └── scene.js 
│   │   ├── managers
│   │   │   └── LoaderManager.js
│   │   └── glsl
│   │       ├── main.frag
│   │       ├── main.vert
│   │       ├── random.frag
│   │       └── random.vert
│   ├── public
│   │   └── img
│   │       ├── favicon.svg
│   │       ├── frame.svg
│   │       ├── left1_sprite_sheet.png
│   │       └── right1_sprite_sheet.png
│   └── scss
│       ├── components
│       │   ├── footer.scss
│       │   ├── scene.scss
│       │   └── title.scss
│       ├── imports
│       │   ├── _colors.scss
│       │   ├── _easings.scss
│       │   ├── _fonts.scss
│       │   ├── _media-queries.scss
│       │   └── index.scss
│       ├── includes
│       │   ├── reset.scss
│       │   └── root.scss
│       └── style.scss
├── vite.config.js

  You are an expert in Python, Django, and scalable web application development.

  rules:
  - You are an expert in Python and Django, emphasizing modularity and reusability.
  - Use PostgreSQL as your primary database, leveraging Django's ORM for interactions.
  - Follow Django's Model-View-Template (MVT) pattern strictly.
  - Prefer Django's function-based views (FBVs)
  - Use Django's built-in user model and authentication framework.
  - Ensure proper error handling and user-friendly error messages.
  - Customize error pages (e.g., 404, 500) to improve user experience.
  - Use Docker Compose for local development and always use docker-compose cmd to run Django.
frontend:
  - Use HTML, Tailwind CSS, and Alpine.js for the front end.
  - Follow Tailwind's utility-first CSS approach and responsive design principles.
  - Leverage Alpine.js for interactive functionality.
  - Ensure semantic HTML structure and accessibility in your UI components.
  - Implement proper component composition and reusability.
  - Optimize client-side performance with lazy loading and minimal JavaScript.

# Full-Stack Web Development

- This is a project to create slides for a bachelor course for (full-stack) web development. The course is part of the 5th semester in a bachelor program called 'Smart Homes & Assistive Technologies'. Students have a 6 weeks crash course in full-stack web development and continue to work on a individual project for the rest of the semester which is the basis for their bachelor thesis.

## Tools

- Use slidev for creating the slides
- Use pnpm as a package manager when required
- Prefer using Vue.js when not specified differently
- Prefer using vite when not specified differently

## Agenda

- www, tcp/ip, http
- html, css, js
- APIs, Web APIs, Browser APIs
- web app (vanilla, vue.js, node.js)
- Front-end Development
- Back-end Development
- Deployment

## Guidelines

- Keep slides concise and focused
- Use code snippets for technical concepts
- Include diagrams for complex architectures
- Highlight key points for each topic
- Focus on core technologies like HTTP, HTML, CSS, and JavaScript
- For backend, focus on JavaScript and using node.js, etc. so keep the amount of "new" languages to be learned at a minimum

## Custom Instructions

- Focus on creating informative slides for full-stack web development lectures
- When mentioning package management, refer to pnpm instead of npm or yarn
- If discussing frontend frameworks, use Vue.js as the primary example
- Consider Vite for build and development tool examples
- As I keep chatting with you, suggest additions for improving the cursorrules file as I add more and more precise instructions about my expectations.
- Emphasize the use of modern ECMAScript features in JavaScript examples
- Include accessibility considerations in the front-end development section
- Add a section on responsive design principles
- Mention security best practices throughout the course
- IMPORTANT: When creating content for md slides, always treat source code as if it's included in an external snippet. never write code in md directly. but add the references files seperatly after the content for md to be created and inclded in the md sections.

# Python Packaging Best Practices 🐍

## Installation Flow
1. Keep setup.py simple - just handle installation
2. Use entry_points for commands
3. Separate installation from first run
4. Use wrapper scripts for complex startup sequences

## Race Conditions
- ❌ Don't: Run commands directly in setup.py
- ❌ Don't: Try to import package during install
- ✅ Do: Use wrapper scripts (start.sh) for first run
- ✅ Do: Show clear instructions after install

## Example Pattern
```bash
# Wrapper script (start.sh)
#!/bin/bash
pip install -e .
sleep 1  # Wait for install
linux-cheats --cli  # Run CLI
linux-cheats --web & # Start web
```

## Setup.py Pattern
```python
setup(
    entry_points={
        'console_scripts': [
            'main-command=package.main:main',
            'setup-command=package.scripts.setup:post_install',
        ],
    }
)
```

## Post-Install Pattern
```python
def post_install():
    """Show instructions after install"""
    print("\n✨ Installation complete!")
    print("To start, run: command-name")
```

## Remember
- Keep installation and execution separate
- Use wrapper scripts for complex flows
- Follow the principle of least surprise
- Give clear user instructions 

{
  "projectStructure": {
    "src": {
      "api": {
        "db": ["index.ts", "schema.ts"],
        "queries": {
          "_pattern": "kebab-case",
          "files": ["index.ts", "{query-name}.ts"],
          "description": "Generic non-feature specific queries"
        },
        "mutations": {
          "_pattern": "kebab-case",
          "files": ["index.ts", "{mutation-name}.ts"],
          "description": "Generic non-feature specific mutations"
        },
        "models": {
          "_pattern": "kebab-case",
          "files": ["index.ts", "{model-name}.z.ts"],
          "description": "Zod validation schemas"
        }
      },
      "components": {
        "_description": "One-time use components and non-feature specific components",
        "layout": ["header.tsx", "sidebar.tsx", "footer.tsx"]
      },
      "core": {
        "config": ["site-config.ts", "fonts.ts"],
        "types": ["{type-name}.d.ts"],
        "animations": ["index.ts"]
      },
      "features": {
        "{feature-name}": {
          "components": ["index.ts", "{component-name}.tsx"],
          "hooks": ["index.ts", "use-{hook-name}.ts"],
          "utils": ["index.ts", "{util-name}.ts"],
          "api": {
            "queries": ["index.ts", "{query-name}.ts"],
            "mutations": ["index.ts", "{mutation-name}.ts"],
            "models": ["index.ts", "{model-name}.z.ts"]
          }
        }
      },
      "shared": {
        "components": {
          "ui": {
            "_description": "shadcn/ui components",
            "files": ["index.ts", "{component-name}.tsx"]
          }
        },
        "helpers": ["index.ts", "{helper-name}.ts"],
        "hooks": ["index.ts", "use-{hook-name}.ts"]
      },
      "services": ["{service-name}.service.ts"],
      "styles": ["globals.css"]
    },
    "main": {
      "_description": "Electron main process files",
      "files": ["index.ts", "preload.ts"]
    },
    "renderer": {
      "_description": "Next.js renderer process files",
      "pages": ["_app.tsx", "index.tsx"],
      "components": {
        "_pattern": "kebab-case",
        "files": ["{component-name}.tsx"]
      }
    },
    "docs": {
      "_description": "Documentation for important features and business logic",
      "files": ["{feature-name}.mdx"]
    },
    "scripts": {
      "_description": "Utility scripts",
      "files": ["{script-name}.sh"]
    }
  },
  "codingStandards": {
    "general": {
      "fileNaming": "kebab-case",
      "preferTypes": true,
      "interfaceUsage": "only when needed",
      "exportStyle": "named exports in index.ts"
    },
    "components": {
      "style": "function declarations",
      "format": "props destructuring",
      "example": [
        "function ComponentName({ prop1, prop2 }) {",
        "  const logic = someLogic",
        "  return (",
        "    <>",
        "      {content}",
        "    </>",
        "  )",
        "}"
      ]
    },
    "documentation": {
      "coreFiles": {
        "format": "jsdoc",
        "template": [
          "/**",
          " * @author Remco Stoeten",
          " * @description Brief description",
          " * @description Additional details if needed",
          " */"
        ]
      },
      "complexFeatures": {
        "format": "mdx",
        "location": "/docs/{feature-name}.mdx"
      }
    },
    "imports": {
      "style": "named imports",
      "ordering": [
        "react/next imports",
        "external libraries",
        "internal absolute imports",
        "internal relative imports",
        "types/interfaces",
        "styles"
      ]
    }
  },
  "database": {
    "naming": {
      "models": "PascalCase",
      "fields": "camelCase",
      "enums": "PascalCase"
    },
    "location": {
      "schema": "prisma/schema.prisma",
      "migrations": "prisma/migrations"
    }
  }
} 

You are an expert programmer in HTML/CSS/Javascript. You are also an excellent educator, walking students through solutions as you build them.

You adhere to common best practices in these languages, including responsive design.

Use HSL colour codes.
When writing javascript:

- You should aim to have as little global code as possible.
- Think carefully about where each bit of logic should reside. Take care to put them in "logical" places.
- Remember the Single Responsibility Principle which states that a class (or object or module... you get the point) should only have ONCE responsibility. This doesn't mean an object can only do one thing, but it does mean that everything an object does should be part of one responsibility.
- DOM elements and queries should not be responsible for storing or handling the implementation details of how an application works. That is not their responsibility, nor is it what they were designed to do. They shouldn't be concerned with storing state details, nor handling the logic required for an app to function correctly. Instead, the DOM should be responsible for reading and displaying the application state to the user and providing an easy-to-use gateway to interact with the methods it needs to. You should extract all the DOM manipulation into its own module.

You are an expert in Flutter, Dart, Riverpod, Freezed, Flutter Hooks, and Firebase.

Key Principles
- Write concise, technical Dart code with accurate examples.
- Use functional and declarative programming patterns where appropriate.
- Prefer composition over inheritance.
- Use descriptive variable names with auxiliary verbs (e.g., isLoading, hasError).
- Structure files: exported widget, subwidgets, helpers, static content, types.

Dart/Flutter
- Use const constructors for immutable widgets.
- Leverage Freezed for immutable state classes and unions.
- Use arrow syntax for simple functions and methods.
- Prefer expression bodies for one-line getters and setters.
- Use trailing commas for better formatting and diffs.

Error Handling and Validation
- Implement error handling in views using SelectableText.rich instead of SnackBars.
- Display errors in SelectableText.rich with red color for visibility.
- Handle empty states within the displaying screen.
- Use AsyncValue for proper error handling and loading states.

Riverpod-Specific Guidelines
- Use @riverpod annotation for generating providers.
- Prefer AsyncNotifierProvider and NotifierProvider over StateProvider.
- Avoid StateProvider, StateNotifierProvider, and ChangeNotifierProvider.
- Use ref.invalidate() for manually triggering provider updates.
- Implement proper cancellation of asynchronous operations when widgets are disposed.

Performance Optimization
- Use const widgets where possible to optimize rebuilds.
- Implement list view optimizations (e.g., ListView.builder).
- Use AssetImage for static images and cached_network_image for remote images.
- Implement proper error handling for Firebase operations, including network errors.

Key Conventions
1. Use GoRouter or auto_route for navigation and deep linking.
2. Optimize for Flutter performance metrics (first meaningful paint, time to interactive).
3. Prefer stateless widgets:
- Use ConsumerWidget with Riverpod for state-dependent widgets.
- Use HookConsumerWidget when combining Riverpod and Flutter Hooks.

UI and Styling
- Use Flutter's built-in widgets and create custom widgets.
- Implement responsive design using LayoutBuilder or MediaQuery.
- Use themes for consistent styling across the app.
- Use Theme.of(context).textTheme.titleLarge instead of headline6, and headlineSmall instead of headline5 etc.

Model and Database Conventions
- Include createdAt, updatedAt, and isDeleted fields in database tables.
- Use @JsonSerializable(fieldRename: FieldRename.snake) for models.
- Implement @JsonKey(includeFromJson: true, includeToJson: false) for read-only fields.

Widgets and UI Components
- Create small, private widget classes instead of methods like Widget _build....
- Implement RefreshIndicator for pull-to-refresh functionality.
- In TextFields, set appropriate textCapitalization, keyboardType, and textInputAction.
- Always include an errorBuilder when using Image.network.

Miscellaneous
- Use log instead of print for debugging.
- Use Flutter Hooks / Riverpod Hooks where appropriate.
- Keep lines no longer than 80 characters, adding commas before closing brackets for multi-parameter functions.
- Use @JsonValue(int) for enums that go to the database.

Code Generation
- Utilize build_runner for generating code from annotations (Freezed, Riverpod, JSON serialization).
- Run 'flutter pub run build_runner build --delete-conflicting-outputs' after modifying annotated classes.

Documentation
- Document complex logic and non-obvious code decisions.
- Follow official Flutter, Riverpod, and Firebase documentation for best practices.

Refer to Flutter, Riverpod, and Firebase documentation for Widgets, State Management, and Backend Integration best practices.

# FastAPI Hexagonal Architecture AI 프롬프트 가이드

## 1. 아키텍처 개요 분석

현재 프로젝트는 다음과 같은 헥사고날 아키텍처 구조를 따르고 있습니다:


```7:23:docs/Hexagonal.md
src/
├── app/
│   ├── api/              # Presentation Layer (FastAPI 엔드포인트)
│   │   ├── v1/
│   │   │   ├── endpoints/ # HTTP 라우트 정의
│   │   │   └── schemas/   # 요청 및 응답 데이터 모델 (Pydantic)
│   ├── core/             # Application Core
│   │   ├── domain/       # 도메인 엔티티와 비즈니스 규칙
│   │   ├── ports/        # Ports 인터페이스 정의 (입력/출력 경계)
│   │   └── services/     # Use Cases와 Application Logic
│   ├── adapters/         # Adapters (외부 시스템과의 통합)
│   │   ├── persistence/  # 데이터베이스 접근 (리포지토리 구현)
│   │   ├── external/     # 외부 API 클라이언트
│   │   └── cli/          # CLI와 같은 비 HTTP 인터페이스
│   ├── config/           # 설정 및 환경 변수 관리
│   └── tests/            # 테스트 코드
├── main.py               # FastAPI 어플리케이션 초기화
```


## 2. 프롬프트 가이드

### 2.1 도메인 엔티티 생성

```markdown
다음 요구사항에 맞는 도메인 엔티티를 생성해주세요:
- 엔티티 이름: [엔티티명]
- 속성: [속성 목록]
- 비즈니스 규칙: [규칙 목록]
- 값 객체: [값 객체 목록]

주의사항:
1. 외부 의존성 없이 순수 도메인 로직만 포함
2. dataclass 데코레이터 사용
3. 비즈니스 메서드 포함
4. 불변성 보장
```

### 2.2 포트 인터페이스 정의

```markdown
다음 요구사항에 맞는 포트 인터페이스를 정의해주세요:
- 포트 종류: [Query/Command/Repository]
- 대상 도메인: [도메인명]
- 필요한 작업: [작업 목록]

주의사항:
1. Protocol 클래스 사용
2. 추상 메서드로 정의
3. 명확한 입출력 타입 명시
4. 단일 책임 원칙 준수
```

### 2.3 어댑터 구현

```markdown
다음 요구사항에 맞는 어댑터를 구현해주세요:
- 어댑터 종류: [DB/외부API/캐시 등]
- 구현할 포트: [포트 인터페이스명]
- 기술 스택: [사용할 기술]

주의사항:
1. 포트 인터페이스 완벽 구현
2. 기술 종속적 코드 격리
3. 예외처리 포함
4. 트랜잭션 관리
```

### 2.4 API 엔드포인트 구현

```markdown
다음 요구사항에 맞는 API 엔드포인트를 구현해주세요:
- 엔드포인트: [HTTP 메서드 및 경로]
- 입력 스키마: [요청 데이터 구조]
- 출력 스키마: [응답 데이터 구조]
- 의존성: [필요한 서비스/포트]

주의사항:
1. FastAPI 라우터 사용
2. Pydantic 모델로 검증
3. 의존성 주입 활용
4. 예외처리 포함
```

### 2.5 서비스 레이어 구현

```markdown
다음 요구사항에 맞는 서비스를 구현해주세요:
- 서비스명: [서비스명]
- 사용할 포트: [포트 목록]
- 구현할 유스케이스: [유스케이스 목록]

주의사항:
1. 단일 책임 원칙 준수
2. 포트를 통한 의존성 주입
3. 트랜잭션 관리
4. 도메인 이벤트 처리
```

## 4. 품질 체크리스트

각 컴포넌트 구현 시 다음 사항을 확인하세요:

1. 도메인 중심
- [ ] 순수한 도메인 로직
- [ ] 외부 의존성 없음
- [ ] 비즈니스 규칙 캡슐화

2. 포트와 어댑터
- [ ] 명확한 인터페이스 정의
- [ ] 구현 교체 가능성
- [ ] 단방향 의존성

3. 의존성 주입
- [ ] 생성자 주입 사용
- [ ] 인터페이스 의존
- [ ] 구현체 분리

4. 테스트 용이성
- [ ] 단위 테스트 가능
- [ ] 목킹 가능
- [ ] 통합 테스트 준비

##한국어로 답변해줘

use bun 
use vitest 
write ts types

# Python 3.12 and ElevenLabs Websockets Project Guidelines

## Python 3.12 Features and Best Practices

1. **Use Python 3.12**: Leverage the latest features and improvements.
2. **Type Hinting**: Utilize Python 3.12's enhanced type hinting capabilities.
3. **Pattern Matching**: Use structural pattern matching for complex conditionals.
4. **F-strings**: Employ f-strings with `=` for debugging (e.g., `f"{variable=}"`).
5. **Asynchronous Programming**: Leverage `asyncio` improvements in Python 3.12.

## Project-Specific Framework and Library Usage

1. **FastAPI**: Use for building high-performance APIs.
2. **Pydantic**: Employ for data validation and settings management.
3. **SQLAlchemy**: Utilize as the ORM for database interactions.
4. **MongoDB**: Use for database migrations.
5. **FastAPI Users**: Implement for comprehensive user management.
6. **FastAPI JWT Auth**: Use for authentication.
7. **FastAPI Mail**: Implement for email functionality.
8. **FastAPI Cache**: Use for efficient caching mechanisms.
9. **FastAPI Limiter**: Implement for rate limiting.
10. **FastAPI Pagination**: Use for paginating list endpoints.

## Coding Standards and Best Practices

1. **PEP 8 Compliance**: Adhere strictly to PEP 8 style guidelines.
2. **Docstrings**: Write clear, concise docstrings for all functions, classes, and modules.
3. **Type Annotations**: Use type hints consistently throughout the codebase.
4. **Error Handling**: Implement comprehensive exception handling with specific exception types.
5. **Logging**: Use the `logging` module for consistent and informative logging.
6. **Environment Variables**: Store configuration in environment variables, never in code.
7. **Testing**: Maintain high test coverage using `pytest`.
8. **Linting and Formatting**: Use tools like `flake8`, `black`, and `isort`.

## ElevenLabs Websockets Best Practices

1. **Connection Management**:

   - Use a single websocket connection for multiple TTS requests when possible.
   - Implement reconnection logic with exponential backoff.
   - Close connections properly when no longer needed.

2. **Text Input**:

   - Stream text input word-by-word for optimal performance and lower latency.
   - Use `flush=true` at the end of each conversation turn or sentence.
   - Limit input text to a maximum of 10,000 characters per request.

3. **Buffering and Latency**:

   - Be aware of the API's buffer system for optimizing Time To First Byte (TTFB).
   - Use the default `chunk_length_schedule` in `generation_config` unless specific latency requirements exist.

4. **Audio Output Handling**:

   - Implement proper error handling for audio chunk reception.
   - Use a separate async task for listening to audio chunks.
   - Buffer received audio chunks appropriately before playing or saving.

5. **Model and Voice Selection**:

   - Use the `eleven_turbo_v2_5` model for lowest latency.
   - Prefer default voices, synthetic voices, or Instant Voice Clones over Professional Voice Clones for lower latency.

6. **API Key and Security**:

   - Never expose the API key in client-side code.
   - Use environment variables to store and access the API key.
   - Implement rate limiting on your server to prevent API key abuse.

7. **Error Handling and Logging**:

   - Implement comprehensive error handling for websocket events and API responses.
   - Log errors and important events for debugging and monitoring.

8. **Performance Optimization**:

   - Reuse SSL/TLS sessions when streaming to reduce latency.
   - Limit the number of websocket connection closures to minimize overhead.

9. **Alignment and Timestamps**:

   - Utilize the `alignment` feature when word-level timestamps are required.
   - Implement proper parsing of alignment data for accurate word timing.

10. **Concurrency and Rate Limiting**:

    - Respect the concurrency limits based on your subscription tier.
    - Implement queuing mechanisms if handling more requests than your concurrency limit.

11. **Audio Format and Quality**:

    - Choose the appropriate `output_format` based on your application's needs.
    - Be aware that higher quality audio formats may increase latency and bandwidth usage.

12. **Testing and Monitoring**:

    - Implement thorough testing, including edge cases and error scenarios.
    - Set up monitoring for websocket connection health and API usage.

13. **Compliance and Usage**:
    - Ensure your use of ElevenLabs' API complies with their terms of service and ethical guidelines.
    - Monitor your API usage to stay within your plan's limits.

## Development Workflow

1. **Version Control**: Use Git for version control, following GitFlow or a similar branching strategy.
2. **Code Reviews**: Require peer code reviews for all changes before merging.
3. **Continuous Integration**: Set up CI/CD pipelines for automated testing and deployment.
4. **Documentation**: Keep API documentation and README files up-to-date.
5. **Dependency Management**: Use `requirements.txt` and consider using virtual environments.

## Security Considerations

1. **Input Validation**: Validate and sanitize all user inputs to prevent injection attacks.
2. **Authentication**: Implement strong authentication mechanisms for all endpoints.
3. **Authorization**: Ensure proper authorization checks for all protected resources.
4. **Data Protection**: Encrypt sensitive data at rest and in transit.
5. **API Rate Limiting**: Implement rate limiting to prevent abuse.

Remember to always refer to the latest ElevenLabs documentation for the most up-to-date information and best practices. Regular code audits and performance reviews will help ensure adherence to these guidelines and maintain high-quality, efficient code.