LexiGuard AI — Contract Review Platform

Concepto

LexiGuard AI es una plataforma SaaS B2B que automatiza la revisión de contratos legales mediante IA. Los profesionales del derecho suben documentos (PDF, DOCX, TXT), y el sistema identifica cláusulas de riesgo, genera resúmenes ejecutivos en lenguaje sencillo y compara cláusulas con plantillas estándar de la industria. El resultado: horas de revisión manual reducidas a segundos.

Target: Pequeños y medianos despachos de abogados, abogados freelance y departamentos legales internos de pymes.

---

Arquitectura

┌─────────────────────────────────────────────────────────────────┐
│                    Spring Boot 4.0.4 / Java 25                  │
├──────────────┬──────────────────────────────┬───────────────────┤
│  Controller  │         Service Layer         │   Infrastructure  │
│              │                              │                   │
│ AuthCtrl     │ UserService                  │ JwtAuthFilter     │
│ ContractCtrl │ ContractService              │ SecurityConfig    │
│              │ AnalysisService (@Async VT)  │ AsyncConfig (VT)  │
│              │ LlmService (Feign + mock)    │ FeignConfig       │
│              │ DocumentParserService        │ JacksonConfig     │
│              │ JwtService                   │                   │
│              │ DataInitializer              │                   │
├──────────────┴──────────────────────────────┴───────────────────┤
│            MapStruct  ·  Spring Data JPA  ·  H2 / PostgreSQL    │
└─────────────────────────────────────────────────────────────────┘
                              │ OpenFeign
                              ▼
                  ┌─────────────────────┐
                  │  LLM API (OpenAI /  │
                  │  compatible)        │
                  │  (mock when no key) │
                  └─────────────────────┘

Decisiones de diseño clave

Decisión	Razón
Virtual threads (@Async)	Análisis LLM es I/O-bound; un VT por tarea maximiza el throughput sin bloquear el pool HTTP
Mock LLM mode	Cuando lexiguard.llm.api-key está vacío, el sistema devuelve datos realistas; permite demos sin API key
Records Java 25 para DTOs	Inmutabilidad, serialización Jackson automática, código conciso
H2 en desarrollo / PostgreSQL en producción	Spring Boot autoconfigura H2 cuando no hay datasource explícita
MapStruct	Mapeos Entity→DTO sin reflexión en tiempo de ejecución, compilación segura
Plantillas en BD	Permite añadir/personalizar templates gold-standard sin redeployment

---

API — Endpoints

Autenticación (/api/auth/** — público)

Método	Endpoint	Descripción
%%INLINE3%%	%%INLINE4%%	Registro de nuevo usuario → devuelve JWT
%%INLINE5%%	%%INLINE6%%	Login con credenciales → devuelve JWT

Registro:

POST /api/auth/register
{
  "email": "abogado@firma.com",
  "password": "secreto123",
  "name": "María López"
}
→ 201 Created
{
  "token": "eyJhbGciOi...",
  "email": "abogado@firma.com",
  "name": "María López",
  "role": "USER"
}

Contratos (/api/contracts/** — requiere JWT)

Método	Endpoint	Descripción
%%INLINE8%%	%%INLINE9%%	Sube contrato (multipart); dispara análisis async
%%INLINE10%%	%%INLINE11%%	Lista todos los contratos del usuario
%%INLINE12%%	%%INLINE13%%	Estado de un contrato concreto
%%INLINE14%%	%%INLINE15%%	Dashboard de riesgos — claúsulas por severidad
%%INLINE16%%	%%INLINE17%%	Resumen ejecutivo — términos, fechas, obligaciones
%%INLINE18%%	%%INLINE19%%	Comparación de cláusula con plantilla estándar

Cabecera requerida: Authorization: Bearer <jwt>

Upload de contrato:

curl -X POST http://localhost:8080/api/contracts/upload \
  -H "Authorization: Bearer <jwt>" \
  -F "file=@contrato.pdf"
→ 202 Accepted
{
  "id": 1,
  "originalFileName": "contrato.pdf",
  "status": "PENDING",
  "uploadedAt": "2026-05-31T10:00:00"
}

Dashboard de riesgos:

GET /api/contracts/1/dashboard
→ 200 OK
{
  "contractId": 1,
  "contractName": "contrato.pdf",
  "criticalCount": 2,
  "warningCount": 3,
  "informationalCount": 2,
  "totalRisks": 7,
  "criticalClauses": [
    {
      "id": 1,
      "clauseText": "The Service Provider shall be liable for any and all damages...",
      "severity": "CRITICAL",
      "category": "Liability",
      "explanation": "Unlimited liability exposes the service provider to uncapped financial risk."
    }
  ],
  "warningClauses": [...],
  "informationalClauses": [...]
}

Resumen ejecutivo:

GET /api/contracts/1/summary
→ 200 OK
{
  "contractId": 1,
  "contractName": "contrato.pdf",
  "summary": "This is a professional services agreement...",
  "keyTerms": ["Service Provider", "Confidential Information", "Governing Law"],
  "keyDates": ["Agreement Date", "Term: 12 months", "Notice: 30 days before renewal"],
  "obligations": [
    "Service Provider: Deliver consulting services on schedule",
    "Client: Pay invoices within 30 days"
  ],
  "analyzedAt": "2026-05-31T10:00:05"
}

Comparación de cláusula:

POST /api/contracts/1/compare
{
  "clauseText": "The Company may terminate this agreement at any time without notice.",
  "category": "Termination"
}
→ 200 OK
{
  "submittedClause": "The Company may terminate...",
  "standardClause": "Either party may terminate upon thirty (30) days' written notice...",
  "standardName": "30-Day Termination for Convenience",
  "category": "Termination",
  "similarityScore": 0.45,
  "riskLevel": "WARNING",
  "recommendation": "The submitted clause is one-sided and lacks a notice period. Negotiate a mutual 30-day termination right with payment for work completed."
}

---

Estados del contrato

PENDING → PROCESSING → ANALYZED
                     ↘ FAILED

El análisis ocurre en un virtual thread dedicado. El cliente puede sondear %%INLINE21%% hasta que %%INLINE22%%.

---

Severidades de riesgo

Severidad	Color	Descripción
CRITICAL	🔴 Rojo	Riesgo legal/financiero significativo; requiere atención inmediata
WARNING	🟡 Amarillo	Cláusula problemática; revisar antes de firmar
INFORMATIONAL	🔵 Azul	Información relevante de bajo riesgo

---

Análisis de Negocio

Modelo de monetización SaaS B2B

Plan	Precio	Límites
Gratuito	€0/mes	2 documentos/mes
Profesional	€49/mes	50 documentos/mes, comparación avanzada
Equipo	€199/mes	Ilimitado, colaboración, roles, audit log

Métricas clave (KPIs)

• Tiempo de análisis promedio: < 30 segundos (vs. 2-4 horas manual)
• Coste por análisis (GPT-4o): ~€0.05–0.15 según longitud
• Margen bruto estimado: ~70% en plan Profesional
• TAM: Mercado legal tech global >$25B en 2025

Ventaja competitiva

1. Especialización — prompts y plantillas calibradas para contratos legales, no uso genérico de IA
2. Biblioteca de templates — cláusulas gold-standard extensible sin redeployment
3. Integración fluida — API REST permite integración con DMS existentes (iManage, NetDocuments)
4. Demo sin fricción — modo mock sin API key reduce la barrera de evaluación

---

Referencias

• Groovy Web Blog — Best AI SaaS Product Ideas 2026
• Spring Boot 4.0.4 — Official Docs
• Spring Security 7.x — JWT stateless authentication
• jjwt 0.12.6 — GitHub
• Spring Cloud OpenFeign 4.2.1 — LLM API client
• MapStruct 1.6.3 — compile-time DTO mapping
• OpenAI Chat Completions API — Reference

---

Cómo ejecutar

Requisitos previos

• Java 25+
• Maven 3.9+

Ejecución en modo demo (sin LLM real)

cd solutions/2026-05-31-lexiguard-ai-analyzer
mvn spring-boot:run

La aplicación arranca en http://localhost:8080 con H2 en memoria. El análisis usa datos mock realistas — no se necesita API key.

Ejecución con LLM real (OpenAI)

mvn spring-boot:run \
  -Dspring-boot.run.jvmArguments="-Dlexiguard.llm.api-key=sk-..." \
  -Dspring-boot.run.jvmArguments="-Dlexiguard.llm.model=gpt-4o"

Ejecución con PostgreSQL

# application-prod.yml
spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/lexiguard
    username: lexiguard
    password: secret
  jpa:
    hibernate:
      ddl-auto: validate

mvn spring-boot:run -Dspring.profiles.active=prod

Compilación

mvn clean compile    # verifica que compila sin errores
mvn clean package    # genera JAR ejecutable
java -jar target/lexiguard-ai-analyzer-0.0.1-SNAPSHOT.jar

Flujo de prueba rápida

# 1. Registro
curl -X POST http://localhost:8080/api/auth/register \
  -H "Content-Type: application/json" \
  -d '{"email":"test@demo.com","password":"demo1234","name":"Test User"}'

# 2. Login (guardar token)
TOKEN=$(curl -s -X POST http://localhost:8080/api/auth/login \
  -H "Content-Type: application/json" \
  -d '{"email":"test@demo.com","password":"demo1234"}' | jq -r .token)

# 3. Subir contrato
curl -X POST http://localhost:8080/api/contracts/upload \
  -H "Authorization: Bearer $TOKEN" \
  -F "file=@contrato.txt"

# 4. Esperar análisis (~2s en mock) y ver dashboard
curl http://localhost:8080/api/contracts/1/dashboard \
  -H "Authorization: Bearer $TOKEN"

# 5. Ver resumen ejecutivo
curl http://localhost:8080/api/contracts/1/summary \
  -H "Authorization: Bearer $TOKEN"

# 6. Comparar cláusula
curl -X POST http://localhost:8080/api/contracts/1/compare \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"clauseText":"Company may terminate at any time without notice.","category":"Termination"}'

---

FinOps Analysis para LexiGuard AI

Estimación de Costos Operativos Mensuales

Para una micro-startup como LexiGuard AI, los costos operativos iniciales se centrarán principalmente en la infraestructura cloud y el consumo de APIs de Large Language Models (LLMs). Se ha realizado una estimación conservadora para asegurar la viabilidad.

1. Estimación de Tokens LLM Mensuales

• Uso por Contrato: Un contrato típico de 20 páginas (aprox. 8,000 palabras) se traduce en unos 10,400 tokens de entrada. El análisis y el resumen pueden generar unos 3,000-5,000 tokens de salida. Estimación total: ~15,000 tokens por contrato.
• Uso Inicial: Asumiendo una base de 10 usuarios gratuitos (1 documento/mes) y 5 usuarios profesionales (5 documentos/mes), más algo de uso interno/pruebas:

(10 usuarios 1 doc/mes) + (5 usuarios * 5 docs/mes) = 10 + 25 = 35 documentos/mes. 35 documentos 15,000 tokens/documento = 525,000 tokens/mes.

• Estimación Final: Se redondea a ~500K tokens/mes para fines de cálculo, utilizando una relación de 80% tokens de entrada y 20% tokens de salida.

2. Desglose de Costos Mensuales

• LLM (OpenAI gpt-4o-mini):

Input: 400K tokens $0.15/1M tokens = $0.06 Output: 100K tokens $0.60/1M tokens = $0.06 * Costo base: $0.12. Se asigna $10/mes para cubrir este costo, incluyendo un buffer para experimentación, reintentos y posibles usos de modelos ligeramente más caros para tareas críticas.

• Cloud Hosting (AWS):

* EC2 t3.small (Spring Boot App): ~ $25/mes (2 vCPU, 2 GiB RAM, apto para carga moderada). * S3 (Almacenamiento de documentos, logs): ~ $5/mes (para unos pocos GBs de almacenamiento y transferencia). * Total Cloud Hosting: $30/mes.

• Base de Datos (AWS RDS PostgreSQL):

* RDS t3.micro (PostgreSQL): ~ $20/mes (2 vCPU, 1 GiB RAM, 20 GiB GP2 SSD).

• Total de Costos Operativos Mensuales: $10 (LLM) + $30 (Cloud Hosting) + $20 (Base de Datos) = $60/mes.

3. Ingresos Mensuales Estimados

Basado en el modelo de monetización SaaS B2B con precios escalonados (plan profesional $35/mes, plan equipo $100-$200/mes):

• Clientes Pagos Iniciales: Asumimos una tracción inicial de 15 clientes de pago, con un promedio de $35/mes (mezcla de planes profesionales y quizás un plan de equipo pequeño).

Ingreso Mensual Estimado: 15 clientes $35/mes = $525/mes. Redondeado a $500/mes para el cálculo del margen.

4. Margen de Beneficio

• Ingresos: $500/mes
• Costos Operativos: $60/mes
• Beneficio Bruto: $500 - $60 = $440/mes

Margen de Beneficio: (($440 / $500) 100) = 88%.

Este alto margen de beneficio es típico para startups SaaS con bajos costos de infraestructura y LLM, asumiendo que no se incluyen otros costos de negocio (marketing, salarios, etc.) en esta estimación FinOps puramente operativa.

Optimizaciones para Reducir Costos (FinOps)

1. Optimización del Consumo de LLM:

Ingeniería de Prompts: Refinar los prompts para ser concisos y directos, reduciendo la cantidad de tokens de entrada sin sacrificar la calidad del análisis. Utilizar técnicas como el few-shot prompting* o resúmenes previos del documento para enfocar el LLM. * Caché Semántico: Implementar un sistema de caché que almacene respuestas del LLM para cláusulas o patrones de riesgo previamente analizados. Si una cláusula idéntica o muy similar ya fue procesada, se puede devolver la respuesta en caché en lugar de realizar una nueva llamada al LLM. * Modelos por Tarea: Utilizar %%INLINE27%% o incluso %%INLINE28%% para tareas de pre-filtrado o análisis de riesgo general, y reservar modelos más potentes (como gpt-4o completo) solo para tareas muy específicas que requieran mayor precisión o para la comparación de cláusulas críticas. Procesamiento Asíncrono: Para el procesamiento de contratos, que es una tarea asíncrona, se podría considerar la ejecución en horarios de menor demanda o en modelos de instancias spot* (aunque con precauciones) si el volumen lo justifica.

1. Optimización de Infraestructura Cloud:

Rightsizing: Monitorizar de cerca el uso de CPU, memoria y I/O de las instancias EC2 y RDS. Escalar a instancias más pequeñas (ej. %%INLINE30%% o %%INLINE31%% si la carga lo permite) o usar instancias burstable* de forma eficiente. * Serverless para Procesamiento: Evaluar la migración del servicio de análisis asíncrono a una arquitectura serverless (ej. AWS Lambda con SQS o Google Cloud Run). Esto permitiría pagar solo por el tiempo de cómputo real durante el procesamiento de un contrato, reduciendo drásticamente los costos de inactividad. * Almacenamiento de Datos: Utilizar clases de almacenamiento de S3 más económicas (ej. S3 Standard-IA o S3 Glacier) para documentos antiguos o de menor acceso, si la política de acceso lo permite. Automatización con IaC: Usar Infraestructura como Código (IaC) con herramientas como Terraform o AWS CloudFormation para aprovisionar y gestionar recursos. Esto ayuda a evitar el shadow IT* y asegura que los recursos estén correctamente configurados y optimizados.

1. Monitoreo y Alertas:

* Configurar alertas de costos en AWS Budgets o GCP Billing para recibir notificaciones si el gasto excede los umbrales predefinidos, especialmente para el uso de LLMs y servicios de base de datos. * Implementar dashboards de observabilidad para correlacionar el uso de recursos con el rendimiento de la aplicación y el costo, identificando rápidamente ineficiencias.