muhammedAdnan3/LawBuddy

Law Buddy Backend Integration Guide

Overview

Law Buddy is an AI-powered legal assistant platform built using FastAPI and Llama 2. This guide provides detailed information for developers looking to integrate with or extend the Law Buddy backend.

Table of Contents

• Prerequisites
• Installation
• Configuration
• API Endpoints
• Model Integration
• Development Guidelines
• Error Handling
• Security Considerations
• Performance Optimization
• Deployment
• Troubleshooting

Prerequisites

Required Software

• Python 3.8+
• CUDA-capable GPU (recommended for production)
• Git
• Virtual environment tool (e.g., venv, conda)

Required Packages

pip install fastapi==0.68.0
pip install uvicorn==0.15.0
pip install transformers==4.30.0
pip install torch==2.0.0
pip install pydantic==1.8.2
pip install python-jwt==3.3.0
pip install python-multipart==0.0.5

Installation

1. Clone the repository:

git clone https://github.com/your-org/law-buddy.git
cd law-buddy

2. Create and activate virtual environment:

python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

3. Install dependencies:

pip install -r requirements.txt

4. Download the Llama 2 model:

# Option 1: Using Hugging Face CLI
huggingface-cli download meta-llama/Llama-2-7b-chat-hf

# Option 2: Using Python script
python scripts/download_model.py

Configuration

Environment Variables

Create a .env file in the root directory:

# Model Configuration
MODEL_PATH="meta-llama/Llama-2-7b-chat-hf"
MODEL_DEVICE="cuda"  # or "cpu"
MAX_LENGTH=512
TEMPERATURE=0.7
TOP_P=0.95

# API Configuration
API_HOST="0.0.0.0"
API_PORT=8000
DEBUG_MODE=True

# Security
JWT_SECRET="your-secret-key"
JWT_ALGORITHM="HS256"
ACCESS_TOKEN_EXPIRE_MINUTES=30

Model Configuration

Adjust model parameters in config/model_config.py:

MODEL_CONFIG = {
    "max_length": 512,
    "temperature": 0.7,
    "top_p": 0.95,
    "do_sample": True,
    "num_return_sequences": 1
}

API Endpoints

Chat Endpoint

POST /chat
Content-Type: application/json

{
    "user_input": string,
    "context": string (optional)
}

Response:

{
    "response": string,
    "confidence": float,
    "references": array[string]
}

Categories Endpoint

GET /categories

Response:

{
    "categories": [
        "criminal_law",
        "civil_law",
        "family_law",
        "corporate_law",
        "intellectual_property"
    ]
}

Model Integration

Custom Prompt Templates

Create new prompt templates in templates/prompts.py:

def create_legal_prompt(user_input: str, context: str = None) -> str:
    base_prompt = """You are Law Buddy, an AI legal assistant...
    User Query: {query}
    """
    return base_prompt.format(query=user_input)

Extending Model Functionality

Add new model capabilities in services/model_service.py:

async def process_legal_query(
    user_input: str,
    context: Optional[str] = None,
    include_references: bool = True
) -> dict:
    # Your implementation here
    pass

Development Guidelines

Code Structure

law-buddy/
├── api/
│   ├── endpoints/
│   ├── middleware/
│   └── dependencies/
├── core/
│   ├── config.py
│   └── security.py
├── models/
│   ├── request_models.py
│   └── response_models.py
├── services/
│   ├── model_service.py
│   └── legal_service.py
├── templates/
│   └── prompts.py
├── utils/
│   └── helpers.py
├── main.py
└── requirements.txt

Adding New Features

1. Create feature branch:

git checkout -b feature/your-feature-name

2. Implement endpoint in api/endpoints/:

@router.post("/your-endpoint")
async def your_endpoint(data: YourRequestModel):
    # Implementation
    pass

3. Add service logic in services/:

class YourService:
    def process_data(self, data: dict) -> dict:
        # Implementation
        pass

Error Handling

Custom Exceptions

Create custom exceptions in core/exceptions.py:

class LegalAssistantException(Exception):
    def __init__(self, message: str, status_code: int = 400):
        self.message = message
        self.status_code = status_code

Exception Handlers

Add handlers in api/middleware/error_handlers.py:

@app.exception_handler(LegalAssistantException)
async def legal_assistant_exception_handler(request, exc):
    return JSONResponse(
        status_code=exc.status_code,
        content={"error": exc.message}
    )

Security Considerations

1. Input Validation

class ChatInput(BaseModel):
    user_input: str = Field(..., min_length=1, max_length=1000)
    context: Optional[str] = Field(None, max_length=500)

2. Rate Limiting

from fastapi import Request
from fastapi.middleware.throttling import ThrottlingMiddleware

app.add_middleware(
    ThrottlingMiddleware,
    rate_limit=100,  # requests
    time_window=3600  # seconds
)

Performance Optimization

1. Model Optimization

def optimize_model():
    model.half()  # Convert to FP16
    model.eval()  # Set to evaluation mode
    torch.backends.cudnn.benchmark = True

2. Caching

from fastapi_cache import FastAPICache
from fastapi_cache.backends.redis import RedisBackend

@app.on_event("startup")
async def startup():
    FastAPICache.init(RedisBackend(), prefix="law-buddy-cache")

Deployment

Docker Deployment

FROM python:3.8-slim

WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . .
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Build and run:

docker build -t law-buddy .
docker run -p 8000:8000 law-buddy

Production Considerations

1. Use environment variables for sensitive data
2. Implement proper logging
3. Set up monitoring
4. Configure CORS properly
5. Implement rate limiting
6. Use HTTPS
7. Set up database backups

Troubleshooting

Common Issues

1. Model Loading Errors

try:
    model = AutoModelForCausalLM.from_pretrained(MODEL_PATH)
except Exception as e:
    logger.error(f"Model loading error: {str(e)}")
    # Fallback logic

2. Memory Issues

import torch
torch.cuda.empty_cache()  # Clear CUDA cache

# Monitor memory usage
print(f"GPU Memory: {torch.cuda.memory_allocated()/1024**2:.2f}MB")

3. API Response Times

import time

@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    start_time = time.time()
    response = await call_next(request)
    process_time = time.time() - start_time
    response.headers["X-Process-Time"] = str(process_time)
    return response

Contributing

1. Fork the repository
2. Create feature branch
3. Commit changes
4. Create pull request

Follow the coding style guide and include tests for new features.

Support

For technical support:

• Create an issue in the GitHub repository
• Contact the development team at
• Check the documentation at

License

This project is licensed under the MIT License - see the LICENSE file for details.