ClauseGuard AI — MVP Explainer

Concept

ClauseGuard AI is a B2B SaaS legal-tech platform that automates contract review. Legal teams and independent lawyers upload NDAs, MSAs, and SOWs; the platform extracts the text, sends it to an LLM, and returns a structured risk report in seconds — replacing hours of manual review.

---

Architecture

┌──────────────┐        JWT        ┌─────────────────────────────────────────────┐
│   Client     │ ──────────────── ▶│            Spring Boot 4 / Java 25          │
│ (Web / CLI)  │                   │                                             │
└──────────────┘                   │  ┌────────────┐  ┌──────────────────────┐  │
                                   │  │AuthController│  │ ContractController   │  │
                                   │  └──────┬─────┘  └──────────┬───────────┘  │
                                   │         │                    │              │
                                   │  ┌──────▼─────┐  ┌──────────▼───────────┐  │
                                   │  │ AuthService │  │ContractAnalysisService│  │
                                   │  └──────┬─────┘  └──┬────────┬──────────┘  │
                                   │         │            │        │              │
                                   │  ┌──────▼──┐  ┌─────▼──┐  ┌─▼────────────┐│
                                   │  │  JPA    │  │TextExtr│  │  LlmClient   ││
                                   │  │  Repos  │  │Service │  │  (Feign)     ││
                                   │  └──────┬──┘  └────────┘  └─────────────┬┘│
                                   │         │                                │  │
                                   └─────────┼────────────────────────────────┼──┘
                                             │                                │
                                      ┌──────▼──────┐            ┌────────────▼──────┐
                                      │ H2 (dev)    │            │ OpenAI-compatible  │
                                      │ PostgreSQL  │            │ LLM API            │
                                      │ (prod)      │            └───────────────────┘
                                      └─────────────┘

Key components

Layer	Class	Responsibility
Security	JwtService	Generate & validate HS256 tokens
Security	%%INLINE1%%	Populate %%INLINE2%% per request
Service	TextExtractionService	Parse PDF/DOCX/TXT to plain text
Service	ContractAnalysisService	Orchestrate upload → LLM → persist
Service	ClauseLibraryService	Manage standard clause templates
Service	DataInitializerService	Seed 10 global standard clauses on startup
Feign	LlmClient	OpenAI Chat Completions integration
Config	SecurityConfig	Stateless JWT, CSRF-off, role-based rules
Config	FeignConfig	Enable Feign client scanning

---

Endpoints

Authentication (public)

Method	Path	Description
%%INLINE10%%	%%INLINE11%%	Create account — returns JWT
%%INLINE12%%	%%INLINE13%%	Exchange credentials for JWT

Register request:

{
  "username": "alice",
  "email": "alice@lawfirm.io",
  "password": "s3cret!"
}

Login / Register response:

{
  "token": "eyJ...",
  "username": "alice",
  "role": "USER"
}

---

Contracts (JWT required)

Method	Path	Description
%%INLINE14%%	%%INLINE15%%	Upload + analyse a contract (multipart file)
%%INLINE17%%	%%INLINE18%%	List user's contracts
%%INLINE19%%	%%INLINE20%%	Contract metadata
%%INLINE21%%	%%INLINE22%%	Full AI analysis result

Upload example (curl):

curl -X POST http://localhost:8080/api/contracts \
  -H "Authorization: Bearer $TOKEN" \
  -F "file=@nda_2026.pdf"

Analysis response:

{
  "contractId": 1,
  "executiveSummary": "This NDA establishes mutual confidentiality...",
  "riskClauses": [
    {
      "title": "Unlimited Liability",
      "severity": "HIGH",
      "description": "No liability cap — exposure to unlimited damages.",
      "originalText": "...shall be liable for all losses..."
    }
  ],
  "clauseComparisons": [
    {
      "clauseName": "Limitation of Liability Cap",
      "category": "LIABILITY",
      "found": false,
      "matchedExcerpt": null,
      "notes": "Standard clause not found in the contract."
    }
  ],
  "missingClauses": ["Force Majeure Clause", "GDPR Data Processing"],
  "status": "COMPLETED",
  "analyzedAt": "2026-05-22T10:30:00Z"
}

---

Clause Library (JWT required)

Method	Path	Description
%%INLINE23%%	%%INLINE24%%	List global + user clauses
%%INLINE25%%	%%INLINE26%%	Add clause to user's library
%%INLINE27%%	%%INLINE28%%	Update user-owned clause
%%INLINE29%%	%%INLINE30%%	Delete user-owned clause

Clause categories: %%INLINE31%%, %%INLINE32%%, %%INLINE33%%, %%INLINE34%%, %%INLINE35%%, %%INLINE36%%, %%INLINE37%%, %%INLINE38%%

---

MVP Features Implemented

Feature	Implementation
✅ PDF upload & parsing	TextExtractionService.extractPdfText() — BT/ET stream scan
✅ DOCX upload & parsing	TextExtractionService.extractDocxText() — ZIP/XML extraction
✅ AI risk clause identification	ContractAnalysisService.callLlm() — structured LLM prompt
✅ Executive summary	Included in LLM response → AnalysisResult.executiveSummary
✅ Standard clause comparison	ContractAnalysisService.compareWithLibrary() — keyword matching

---

Business Analysis

Problem

Legal teams spend 2–8 hours reviewing a single standard contract (NDA, MSA, SOW). At $300–$500/hour for qualified legal counsel, each review costs $600–$4,000.

Solution

ClauseGuard AI reduces that to < 30 seconds per contract at marginal cost.

Monetisation

Tier	Price/month	Contracts	Users
Starter	$99	20	1
Professional	$399	100	5
Enterprise	$1,499+	Unlimited	Unlimited + SSO

Target metrics (12 months)

• 500 paying customers → $200k ARR (mix of tiers)
• LLM cost per analysis: ~$0.03 (gpt-4o-mini, 12k tokens) → 97%+ gross margin
• Payback period: Day 1 for customers reviewing ≥ 2 contracts/month

---

How to Run

Development (H2 in-memory, no LLM key required)

cd solutions/2026-05-22-clauseguard-ai
mvn spring-boot:run

The app starts on http://localhost:8080. H2 console: %%INLINE45%% (JDBC URL: %%INLINE46%%). Without app.llm.api-key, the service returns a demo analysis for every contract.

With real LLM (OpenAI)

SPRING_APPLICATION_JSON='{"app":{"llm":{"api-key":"sk-...","model":"gpt-4o-mini"}}}' \
  mvn spring-boot:run

Or set in application.yml:

app:
  llm:
    base-url: https://api.openai.com/v1
    api-key: sk-...
    model: gpt-4o-mini
  jwt:
    secret: <base64-encoded-256-bit-key>
    expiration-ms: 86400000

Production (PostgreSQL + Docker)

docker build -t clauseguard-ai:latest .

docker run -p 8080:8080 \
  -e SPRING_DATASOURCE_URL=jdbc:postgresql://db:5432/clauseguard \
  -e SPRING_DATASOURCE_USERNAME=clauseguard \
  -e SPRING_DATASOURCE_PASSWORD=secret \
  -e SPRING_JPA_HIBERNATE_DDL_AUTO=update \
  -e APP_LLM_API_KEY=sk-... \
  -e APP_JWT_SECRET=<base64-key> \
  clauseguard-ai:latest

---

Production Enhancements (Post-MVP)

• Replace basic PDF/DOCX extractor with Apache PDFBox + Apache POI
• Add %%INLINE49%% for %%INLINE50%% / @Size on DTOs
• Rate limiting per user (Bucket4j + Redis)
• Async analysis with @Async + virtual threads for large files
• S3/GCS encrypted object storage for original files
• Multi-tenancy and team management
• Webhook notifications when analysis completes

---

References

• Best AI SaaS Product Ideas 2026 — GroovyWeb
• Spring Boot 4.0.x Reference
• OpenAI Chat Completions API
• jjwt 0.12.x Guide
• Spring Cloud OpenFeign

---

Análisis FinOps para ClauseGuard AI

Estimación de Costos Operativos Mensuales

Para ClauseGuard AI, los costos operativos iniciales se dividen principalmente en dos categorías: consumo de LLM y la infraestructura cloud.

1. Estimación de Tokens LLM

Asumiendo un escenario inicial de MVP con 20 clientes, donde cada cliente procesa un promedio de 5 contratos al mes, y cada contrato tiene aproximadamente:

• Longitud del Contrato: 15 páginas (aprox. 7500 palabras).

Tokens de Contenido: ~9,750 tokens (7500 palabras 1.3 tokens/palabra).

• Tokens de Prompt (instrucciones, ejemplos): ~2,000 tokens.
• Tokens de Salida (resumen, análisis de riesgos): ~2,000 tokens.
• Total de Tokens por Contrato: ~13,750 tokens.

Con 100 contratos al mes (20 clientes * 5 contratos/cliente): Total de Tokens Mensuales: 100 contratos 13,750 tokens/contrato = 1,375,000 tokens (aprox. 1.5M tokens/mes).

2. Desglose de Costos Mensuales

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

Input: 1.175M tokens ($0.15 / 1M tokens) = $0.176 Output: 0.2M tokens ($0.60 / 1M tokens) = $0.12 * Subtotal LLM: ~$0.30. Para fines de FinOps y un pequeño buffer por fluctuaciones o re-intentos, estimamos $10/mes.

• Costos de Infraestructura Cloud (ej. AWS/GCP/Azure):

* Máquina Virtual (Spring Boot App): Un servidor básico (ej. AWS t3.small, GCP e2-small) para la aplicación Spring Boot. Estimación: $20/mes. * Base de Datos (PostgreSQL gestionada): Una instancia de base de datos pequeña (ej. AWS RDS db.t3.micro, GCP Cloud SQL db-f1-micro) para almacenar usuarios, contratos y resultados de análisis. Estimación: $15/mes. * Almacenamiento de Objetos (S3/GCS/Blob Storage): Para almacenar los contratos originales de forma segura. El costo será mínimo para el volumen inicial. Estimación: $3/mes. * Red y Monitoreo: Transferencia de datos y servicios básicos de monitoreo/logs. Estimación: $2/mes. * Subtotal Cloud Hosting: $40/mes.

• Costos Totales Mensuales Estimados: $10 (LLM) + $40 (Cloud) = $50/mes.

Estimación de Ingresos Mensuales

Basado en un modelo de suscripción B2B por niveles, con un plan básico de $25/mes para usuarios individuales o pequeñas empresas que procesan ~5-10 contratos/mes. Ingresos Mensuales Estimados: 20 clientes $25/cliente = $500/mes.

Margen de Beneficio

Cálculo: ((Ingresos - Costos) / Ingresos) 100 (( $500 - $50 ) / $500) 100 = ($450 / $500) * 100 = 90%.

El alto margen de beneficio inicial es muy favorable, impulsado por el bajo costo de los LLM de última generación como gpt-4o-mini y una infraestructura cloud lean para el MVP.

Optimizaciones FinOps Concretas para Reducir Costos

1. Caching de Respuestas LLM: Implementar una capa de caché robusta para las respuestas del LLM. Si un contrato o una cláusula específica ya ha sido analizada, o si las instrucciones del prompt son idénticas, se puede servir la respuesta desde caché, eliminando la necesidad de llamar al LLM nuevamente. Esto es especialmente útil para cláusulas estándar o contratos repetitivos.
2. Optimización de Prompts: Realizar ingeniería de prompts continua para asegurar que sean lo más concisos y eficientes posible. Cada token cuenta; eliminar redundancias y mejorar la claridad puede reducir significativamente los tokens de entrada y salida, impactando directamente el costo del LLM.
3. Uso de Serverless para Procesamiento: Migrar la lógica de análisis de contratos a funciones serverless (ej. AWS Lambda, Google Cloud Functions). Esto permite pagar solo por el tiempo de cómputo real durante el análisis de un contrato, en lugar de tener una VM siempre encendida, lo que puede generar ahorros sustanciales a medida que el volumen de procesamiento fluctúa.
4. Monitoreo y Alertas de Costos: Configurar herramientas de monitoreo de costos en la nube (ej. AWS Cost Explorer, GCP Billing Reports) con alertas personalizadas. Esto permitirá detectar rápidamente cualquier aumento inesperado en el consumo de recursos o llamadas a la API de LLM, facilitando una acción correctiva inmediata.
5. Gestión de Almacenamiento de Documentos: Implementar políticas de ciclo de vida para los documentos almacenados en S3/Blob Storage. Por ejemplo, mover documentos antiguos a clases de almacenamiento más baratas (ej. S3 Glacier) después de un período, o eliminar los originales una vez extraído el texto y procesado, si las políticas de cumplimiento y privacidad lo permiten. Asegurar que los documentos estén comprimidos antes de ser almacenados.
6. Extracción de Texto en el Cliente: Si es viable desde el punto de vista técnico y de seguridad, realizar la extracción inicial de texto de los PDFs/DOCX en el lado del cliente (navegador) antes de enviarlo al backend. Esto reduce el tamaño de la carga útil enviada al servidor y, por ende, el tráfico de red, lo que puede contribuir a pequeños ahorros en la transferencia de datos.
7. Evaluación Continua del Modelo LLM: Aunque gpt-4o-mini es muy económico, evaluar periódicamente si modelos de código abierto o modelos más pequeños y especializados podrían manejar tareas específicas con suficiente calidad a un costo aún menor, especialmente a medida que la startup escala y las necesidades se vuelven más específicas.