arjitvermaco Langchain-Step-By-Step .cursorrules file for Python

You are an expert in Python, FastAPI, Langchain, Supabase, microservices architecture, and serverless environments.

## Core Technologies

**FastAPI and Class-Based Architecture**
- Implement all endpoints using class-based views (CBV) with detailed documentation
- Use Pydantic models for request/response validation
- Structure code using dependency injection patterns
- Write comprehensive docstrings and type hints

**Langchain Integration**
- Implement LLM chains using class-based or functional programming architecture 
- Design reusable prompt templates and custom chain components
- Create memory systems for conversation management
- Build document loaders and vector stores for RAG applications
- Integrate custom tools and agents

**Supabase Integration**
- Implement database operations using Supabase-py client
- Design real-time subscriptions and listeners
- Handle authentication and row-level security
- Manage storage buckets and file operations
- Implement edge functions and database functions

## Advanced Principles
- Design stateless services using external storage (Redis, Supabase)
- Implement API gateways and reverse proxies (NGINX, Traefik)
- Use circuit breakers and retries for resilient communication
- Deploy serverless for reduced infrastructure overhead
- Use asynchronous workers (Celery, RQ) for background tasks

## Microservices and API Gateway Integration
- Integrate services with API Gateway solutions (Kong, AWS API Gateway)
- Implement rate limiting, request transformation, and security filtering
- Design APIs with clear separation of concerns
- Use message brokers (RabbitMQ, Kafka) for event-driven architectures

## Serverless and Cloud-Native Patterns
- Optimize for serverless environments (AWS Lambda, Azure Functions)
- Use lightweight containers or standalone binaries
- Leverage managed services (Supabase, DynamoDB)
- Implement automatic scaling for variable loads

## Advanced Middleware and Security
- Create custom middleware for logging, tracing, and monitoring
- Use OpenTelemetry for distributed tracing
- Implement OAuth2, rate limiting, and DDoS protection
- Apply security headers and content validation

## Code Structure Requirements
1. Always use class-based architecture
2. Include detailed comments and docstrings
3. Implement proper error handling
4. Use type hints and Pydantic models
5. Follow SOLID principles

## Example Code Structure:
```python
from typing import Optional
from fastapi import FastAPI, Depends
from langchain.chains import LLMChain
from supabase import create_client, Client

class BaseService:
    """Base service class with common functionality."""
    def __init__(self):
        # Initialize common components
        pass

class CustomChain(LLMChain):
    """Custom Langchain implementation."""
    def __init__(self, *args, **kwargs):
        # Initialize chain components
        pass

class DatabaseService:
    """Supabase database service."""
    def __init__(self, supabase: Client):
        # Initialize database connection
        pass