---
title: CyberLegalAIendpoint
sdk: docker
app_port: 8000
---
# CyberLegal AI - LangGraph Agent

Advanced cyber-legal assistant powered by LangGraph + LightRAG + GPT-5-Nano for European regulations expertise.

## 🏗️ Architecture

```
┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│   Client API    │────│  LangGraph Agent │────│  LightRAG Server│
│   (Port 8000)  │    │   (Orchestration)│    │  (Port 9621)    │
└─────────────────┘    └──────────────────┘    └─────────────────┘
                               │
                       ┌──────────────┐
                       │ GPT-5-Nano   │
                       │ (Reasoning)   │
                       └──────────────┘
```

## 🚀 Quick Start

### Using Docker Compose (Recommended)

1. **Environment Setup**
   ```bash
   # Copy and configure environment
   cp .env.example .env
   
   # Edit .env with your API keys
   # OPENAI_API_KEY=your_openai_key
   # LIGHTRAG_API_KEY=your_lightrag_key (optional)
   ```

2. **Deploy**
   ```bash
   docker-compose up -d
   ```

3. **Verify Deployment**
   ```bash
   curl http://localhost:8000/health
   ```

### Using Docker Directly

```bash
# Build the image
docker build -t cyberlegal-ai .

# Run the container
docker run -d \
  --name cyberlegal-ai \
  -p 8000:8000 \
  -e OPENAI_API_KEY=your_key \
  -v $(pwd)/rag_storage:/app/rag_storage \
  cyberlegal-ai
```

## 📡 API Usage

### Base URL
```
http://localhost:8000
```

### Endpoints

#### Chat with Assistant
```bash
curl -X POST "http://localhost:8000/chat" \
  -H "Content-Type: application/json" \
  -d '{
    "message": "What are the main obligations under GDPR?",
    "role": "client",
    "jurisdiction": "EU",
    "conversationHistory": []
  }'
```

#### Health Check
```bash
curl http://localhost:8000/health
```

#### API Info
```bash
curl http://localhost:8000/
```

## 📝 Request Format

```json
{
  "message": "User's legal question",
  "role": "client" | "lawyer",
  "jurisdiction": "EU" | "France" | "Germany" | "Italy" | "Spain" | "Romania" | "Netherlands" | "Belgium",
  "conversationHistory": [
    {"role": "user|assistant", "content": "Previous message"}
  ]
}
```

## 📤 Response Format

```json
{
  "response": "Detailed legal answer with references",
  "confidence": 0.85,
  "processing_time": 2.34,
  "references": ["gdpr_2022_2555.txt", "nis2_2022_2555.txt"],
  "timestamp": "2025-01-15T10:30:00Z",
  "error": null
}
```

## 🧠 Expertise Areas

- **GDPR** (General Data Protection Regulation)
- **NIS2** (Network and Information Systems Directive 2)
- **DORA** (Digital Operational Resilience Act)
- **CRA** (Cyber Resilience Act)
- **eIDAS 2.0** (Electronic Identification, Authentication and Trust Services)
- Romanian Civil Code provisions

## 🔄 Workflow

1. **User Query** → API receives request with role/jurisdiction context
2. **LightRAG Retrieval** → Searches legal documents for relevant information
3. **LangGraph Processing** → Orchestrates the workflow through nodes:
   - Query validation
   - LightRAG integration
   - Context enhancement with GPT-5-Nano
   - Response formatting
4. **Enhanced Response** → Returns structured answer with confidence score

## 🛠️ Development

### Local Development

```bash
# Install dependencies
pip install -r requirements.txt

# Start LightRAG server (required)
lightrag-server --host 127.0.0.1 --port 9621

# Start the API
python agent_api.py
```

### Environment Variables

```bash
OPENAI_API_KEY=your_openai_api_key
LIGHTRAG_API_KEY=your_lightrag_api_key
LIGHTRAG_HOST=127.0.0.1
LIGHTRAG_PORT=9621
API_PORT=8000
```

## 📁 Project Structure

```
CyberlegalAI/
├── agent_api.py          # FastAPI server
├── langraph_agent.py     # Main LangGraph workflow
├── agent_state.py        # State management
├── prompts.py           # System prompts
├── utils.py             # LightRAG integration
├── requirements.txt      # Python dependencies
├── Dockerfile          # Container configuration
├── docker-compose.yml   # Orchestration
├── rag_storage/        # LightRAG data persistence
└── .env               # Environment variables
```

## 🔧 Configuration

### Port Management
- **Port 8000**: API (exposed externally)
- **Port 9621**: LightRAG (internal only, for security)

### Security Features
- LightRAG server not exposed externally
- API key authentication support
- Non-root container execution
- Health checks and monitoring

## 📊 Monitoring

### Health Checks
```bash
# Container health
docker ps

# Service health
curl http://localhost:8000/health

# Logs
docker logs cyberlegal-ai
```

### Performance Metrics
The API returns:
- Processing time per request
- Confidence scores
- Referenced documents
- Error tracking

## 🚨 Error Handling

The API gracefully handles:
- LightRAG server unavailability
- OpenAI API errors
- Invalid request format
- Network timeouts

## 📚 API Examples

### Client Role Example
```json
{
  "message": "What should my small business do to comply with GDPR?",
  "role": "client",
  "jurisdiction": "France"
}
```

### Lawyer Role Example
```json
{
  "message": "Analyze the legal implications of NIS2 for financial institutions",
  "role": "lawyer",
  "jurisdiction": "EU"
}
```

### Comparison Query
```json
{
  "message": "Compare incident reporting requirements between NIS2 and DORA",
  "role": "client",
  "jurisdiction": "EU"
}
```

## 🤝 Integration Examples

### Python Client
```python
import requests

response = requests.post("http://localhost:8000/chat", json={
    "message": "What are GDPR penalties?",
    "role": "client",
    "jurisdiction": "EU",
    "conversationHistory": []
})

result = response.json()
print(result["response"])
```

### JavaScript Client
```javascript
const response = await fetch('http://localhost:8000/chat', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    message: 'GDPR requirements',
    role: 'client',
    jurisdiction: 'EU',
    conversationHistory: []
  })
});

const result = await response.json();
console.log(result.response);
```

## 📋 Troubleshooting

### Common Issues

1. **LightRAG Connection Failed**
   - Verify LightRAG server is running on port 9621
   - Check container logs: `docker logs cyberlegal-ai`

2. **OpenAI API Errors**
   - Verify OPENAI_API_KEY is set correctly
   - Check API key permissions and quota

3. **Slow Responses**
   - Monitor processing time in API response
   - Check LightRAG document indexing

### Debug Mode

Enable debug logging:
```bash
docker-compose logs -f cyberlegal-api
```

## 📜 License

This project provides general legal information and is not a substitute for professional legal advice.

## 🔄 Updates

The system automatically:
- Retrieves latest regulatory documents
- Updates knowledge base through LightRAG
- Maintains conversation context
- Provides confidence scoring