A fully functional neuro-symbolic legal AI system that transforms legal opinions from passive archives into active cognitive systems.

Phase 0-2: Foundation & Knowledge Construction

• ✅ Infrastructure: 7 services (Neo4j, Qdrant, Label Studio, Camunda, GraphDB, Embedding, OCR)
• ✅ OCR Support: Extract text from PDFs and images (Romanian language)
• ✅ Batch Processing: Process multiple documents in one workflow
• ✅ Uzucapiune Ontology: Complete OWL/Turtle ontology encoding Romanian Civil Code
• ✅ Annotation Pipeline: LLM pre-annotation + human validation + Neo4j export

Phase 3: Symbolic Reasoning

• ✅ DMN Decision Tables: Rule-based evaluation of legal conditions (Art. 928, 930, 931)
• ✅ Camunda Integration: Production-grade DMN engine integration
• ✅ Symbolic Workflow: Automated evaluation of possession validity

Phase 4: Contextual Reasoning

• ✅ GraphRAG Service: Hybrid vector + graph retrieval
• ✅ Similar Case Finder: Identify precedents based on semantic similarity
• ✅ Entity Context Builder: Graph traversal for rich contextual analysis
• ✅ RAG Analysis Workflow: Claude Sonnet-powered contextual legal analysis

Phase 5: Synthesis & Playbook Generation

• ✅ Synthesis Workflow: Combines symbolic + contextual reasoning
• ✅ Legal Assessment: Strength evaluation, success probability, risk analysis
• ✅ Playbook Generator: Actionable recommendations with priorities and timelines
• ✅ Full Transparency: Complete reasoning chains for auditability

End-to-End Orchestration

• ✅ Complete Pipeline: From document to playbook in one workflow
• ✅ Modular Architecture: Skip any phase, start from any point
• ✅ Comprehensive Testing: Full test suite for all phases

# 1. Start infrastructure
cd infrastructure
docker-compose up -d

# 2. Setup reasoning engine
cd ../reasoning-engine
cp .env.example .env
# Edit .env and add ANTHROPIC_API_KEY

# 3. Install and test
npm install
npm run test:ingestion

Detailed setup: See SETUP.md

Logos este un sistem complet de analiză juridică bazat pe:

• VoltAgent: Orchestrare multi-agent (TypeScript) ✅
• Knowledge Graph: Neo4j pentru entități și relații ✅
• GraphRAG: Hybrid vector + graph retrieval ✅
• DMN: Camunda pentru decision services ✅
• LLM: Anthropic Claude pentru raționament complex ✅
• OWL Ontologies: Semantic modeling of legal concepts ✅

Sistemul nu oferă o opinie juridică finală, ci construiește un model logic al problemei, evidențiind:

• Punctele critice de decizie
• Probabilitatea de succes bazată pe date istorice
• Axiome logice extrase din opinii juridice anterioare
• Toate deducțiile posibile cu punctele ambigue izolate

"Consolă de Jocuri" - Separarea Motor vs. Module de Cunoaștere

• Motorul de Raționament: Componente tehnice generice (VoltAgent, orchestration, RAG pipeline)
• Module de Cunoaștere: Logică juridică specifică (ontologii, reguli DMN, date KG) pentru fiecare domeniu (uzucapiune, vicii ascunse, etc.)

Sistemul este extensibil la orice domeniu juridic fără modificarea codului de bază.

Sinteza dintre:

• Raționament Simbolic: Logică bazată pe reguli (DMN), ontologii, knowledge graphs
• Raționament Probabilistic: LLMs pentru contextualizare, interpretare, generare

Fiecare output poate fi urmărit înapoi la:

• Regulile specifice din DMN/KG
• Fragmentele de text din RAG
• Lanțul complet de raționament

Logica juridică NU este hardcodată - există ca fișiere de configurație (DMN, ontologii, date KG) în Module de Cunoaștere.

logos/
├── README.md                          # Acest fișier
├── SETUP.md                           # Ghid complet de setup
├── docs/                              # Documentație comprehensivă
│   ├── architecture.md                # Arhitectura sistemului
│   ├── technology-stack.md            # Recomandări tehnologice
│   ├── implementation-roadmap.md      # Plan de implementare
│   └── phase-guides/
│       └── phase-1-ingestion-annotation.md
├── infrastructure/
│   └── docker-compose.yml             # ✅ Neo4j, Qdrant, Label Studio, etc.
├── reasoning-engine/                  # ✅ VoltAgent multi-agent system
│   ├── src/
│   │   ├── workflows/                 # ✅ Ingestion workflow
│   │   ├── tools/                     # ✅ Text processing, metadata, embeddings
│   │   ├── services/                  # ✅ Neo4j, logger
│   │   ├── config/                    # ✅ Environment configuration
│   │   └── test/                      # ✅ Test ingestion
│   ├── package.json
│   └── tsconfig.json
├── services/
│   └── embedding-service/             # ✅ Python/FastAPI embedding service
│       ├── main.py
│       ├── Dockerfile
│       └── requirements.txt
├── services/
│   ├── ocr-service/                   # ✅ Python/FastAPI OCR (Tesseract)
│   │   ├── main.py
│   │   ├── Dockerfile
│   │   └── requirements.txt
├── knowledge-modules/
│   └── uzucapiune/                    # ✅ Phase 2
│       └── ontology/
│           └── uzucapiune-core.ttl    # ✅ OWL/Turtle ontology
└── annotation-platform/               # ✅ Phase 2
    ├── label-studio-uzucapiune-config.xml
    ├── annotation-guidelines.md
    └── README.md

✅ = Implementat | 🔄 = În curs | ⏳ = Viitor

• VoltAgent project initialized
• Docker Compose infrastructure
• Neo4j, Qdrant, Label Studio, Camunda, GraphDB
• Embedding service (multilingual-e5-large)
• Configuration management
• Logging service

• Text normalization (Romanian legal text)
• Semantic segmentation
• Metadata extraction (Claude Haiku)
• Embedding generation (1024-dim vectors)
• Neo4j storage (documents + chunks)
• Ingestion workflow
• Test suite
• OCR integration (for PDF processing)
• Batch processing workflow

• Ontology design (uzucapiune-core.ttl in OWL/Turtle)
• Label Studio configuration
• Annotation guidelines (comprehensive Romanian/English)
• LLM pre-annotation agent (Claude Haiku)
• Pre-annotation workflow
• Export annotations to Neo4j workflow
• Complete annotation pipeline
• Human-in-the-loop validation (manual step - ongoing)
• 50+ legal opinions annotated (manual process)

• DMN decision tables design (uzucapiune-decision.dmn)
• Camunda DMN engine integration
• DMN service implementation
• Symbolic reasoning workflow
• Rule-based validation (Art. 928, 930, 931)
• Batch symbolic reasoning

• GraphRAG service (hybrid vector + graph)
• Vector similarity search with Neo4j
• Graph context enrichment
• Similar case finder
• Entity context builder
• RAG analysis workflow with Claude Sonnet
• Precedent retrieval and ranking

• Synthesis workflow orchestration
• Symbolic + contextual integration
• Legal assessment generation
• Success probability calculation
• Risk factor identification
• Actionable playbook generation
• Complete reasoning chain tracking
• Neo4j result storage

• Complete pipeline orchestration
• Modular phase control (skip/enable any phase)
• Multiple entry points (file/document/case)
• Comprehensive error handling
• Full transparency and auditability
• Performance metrics tracking

┌─────────────────┐
│ Legal Document  │
│ (PDF/Image/TXT) │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│   OCR Extract   │  ← Tesseract (Romanian) for PDF/images
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  Normalization  │  ← Fix OCR errors, Romanian diacritics
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  Segmentation   │  ← Semantic chunks (500 chars, 50 overlap)
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│ Metadata Extract│  ← Claude Haiku: parties, dates, domain
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  Embeddings     │  ← 1024-dim vectors (multilingual-e5-large)
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  Neo4j Storage  │  ← Document + Chunks + Embeddings
└─────────────────┘

┌─────────────────┐
│  Neo4j Document │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│ Pre-annotation  │  ← Claude Haiku extracts entities/relations
│   (LLM Agent)   │     based on uzucapiune ontology
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  Label Studio   │  ← Human validation & correction
│ (Human-in-Loop) │     using annotation guidelines
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│ Export to Neo4j │  ← Create PersoanaFizica, Imobil, Posesie
│ (Domain Nodes)  │     nodes with relationships
└─────────────────┘

# Phase 1: Text Ingestion & Preprocessing
npm run test:ingestion        # Single document ingestion (OCR + embeddings)
npm run test:batch            # Batch document processing

# Phase 2: Annotation Pipeline
npm run test:preannotation    # Pre-annotate with Claude Haiku
npm run test:annotation       # Complete annotation workflow

# Phase 3-5: Complete System Test
npm run test:e2e              # 🎯 END-TO-END TEST (ALL PHASES)
                              # Ingestion → Annotation → Symbolic → RAG → Synthesis
                              # Full playbook generation with reasoning chain

✅ Ingestion workflow completed successfully!
Document ID: DOC_TEST_001_1731835200000
Chunks created: 8
Metadata extracted:
  - Document type: opinie juridică
  - Legal domain: uzucapiune
  - Parties: Ion Popescu
  - Dates: 2024-03-15, 2013-01-01
  - Keywords: uzucapiune, posesie, bună-credință

Document found in Neo4j:
  - ID: DOC_TEST_001_1731835200000
  - Case ID: TEST_001
  - Domain: uzucapiune
  - Chunks: 8
  - Created: 2024-11-17T09:00:00Z

Utilizatorul selectează domeniul juridic (ex: "Vicii Ascunse") → Motorul încarcă ontologia, regulile DMN, indexul vectorial

Datele cazului nou sunt ingerate (descriere client, documente, conversații) → Orchestratorul execută serviciile de decizie DMN → Fiecare decizie validată pe baza regulilor din KG → Rezultat: arbore de decizie complet

La noduri ambigue în arborele de decizie → Pipeline RAG caută fragmente similare în indexul vectorial → LLM (Claude Sonnet) generează analiză de risc/interpretare

Toate căile din arborele de decizie rezolvate → Serviciu final colectează rezultatele → Folosește șabloane (IRAC, email) pentru document strategic

• SETUP.md - Ghid complet de instalare și configurare
• Architecture - Arhitectura detaliată cu exemple
• Technology Stack - Analiză tehnologică comprehensivă
• Implementation Roadmap - Plan detaliat 5 faze
• Phase 1 Guide - Ghid implementare

• Node.js >= 18.0.0
• Docker & Docker Compose
• Anthropic API key

# Start services
docker-compose -f infrastructure/docker-compose.yml up -d

# Test ingestion
cd reasoning-engine
npm install
npm run test:ingestion

Reasoning Engine:

npm run dev           # Development mode (watch)
npm run build         # Build TypeScript
npm start             # Run compiled code
npm run test:ingestion # Test ingestion workflow

Infrastructure:

docker-compose up -d    # Start all services
docker-compose ps       # Check status
docker-compose logs -f  # View logs
docker-compose down     # Stop all services

• Neo4j Browser: http://localhost:7474 (neo4j / logospassword)
• Qdrant Dashboard: http://localhost:6333/dashboard
• Label Studio: http://localhost:8080
• Camunda: http://localhost:8081
• GraphDB: http://localhost:7200
• Embedding API Docs: http://localhost:8082/docs

Total: 20 săptămâni (~5 luni)

1. VoltAgent oferă orchestrare excelentă:

   • TypeScript type-safety
   • Built-in observability (VoltOps)
   • Declarative workflows

2. Hybrid approach (LPG + OWL):

   • Neo4j pentru performance
   • OWL pentru semantic reasoning

3. Embedding service funcționează perfect:

   • multilingual-e5-large pentru română
   • 1024 dimensions
   • ~100-200ms latency

4. Metadata extraction cu Claude Haiku:

   • Fast și accurate
   • Cost-effective
   • Good JSON parsing

1. Add OCR support pentru PDF processing
2. Batch ingestion pentru multiple documents
3. Start Phase 2: Ontology design în Protégé
4. Label Studio configuration pentru annotation
5. 50 legal opinions annotation

MIT License - See LICENSE file for details

Dezvoltat pentru domeniul juridic românesc, cu focus pe transformarea expertizei avocațiale în sisteme cognitive active.

• VoltAgent Documentation
• VoltAgent GitHub
• Neo4j Documentation
• Anthropic API

Status: Faza 0 & 1 implementate cu succes! 🎉 Ready for: Phase 2 - Annotation Pipeline