> ## Documentation Index
> Fetch the complete documentation index at: https://docs.divorce.law/llms.txt
> Use this file to discover all available pages before exploring further.
# Backend AI Functions
> Autonomous AI systems working behind the scenes to extract insights, manage memory, and automate workflows
## Overview
Beyond the 4 interactive chat agents, Victoria AI OS includes **15+ backend AI functions** that work automatically behind the scenes to:
* Extract structured data from conversations and documents
* Generate case insights and portfolio analytics
* Manage CaseMind™ memory and fact storage
* Auto-complete tasks and archive deadlines
* Track billable time and AI usage
* Orchestrate complex multi-step workflows
**Zero Configuration Required**: Backend AI functions run automatically based on user interactions. You don't need to manually trigger them.
***
## Case Intelligence
### Case Insights (victoria-case-manager)
**What It Does:**
Analyzes your entire case portfolio and generates AI-powered insights about momentum, deadlines, phase transitions, documentation gaps, and opportunities.
**Key Features:**
* **Portfolio Health Scoring**: Evaluates overall case load health
* **Momentum Detection**: Identifies stalled cases (no activity in 14+ days)
* **Deadline Alerts**: Highlights upcoming hearings and critical dates
* **Phase Transition Recommendations**: Suggests when cases are ready to move forward
* **Documentation Gap Analysis**: Detects missing financial documents or discovery materials
**How It Works:**
1. Runs automatically on dashboard load
2. 24-hour caching for performance
3. Analyzes all active cases in your firm
4. Generates 5-10 actionable insights with severity ratings (critical/high/medium/low)
**Output Example:**
```json theme={null}
{
"type": "momentum",
"severity": "high",
"title": "Case stalled: Johnson v. Johnson",
"description": "No activity in 18 days. Last action: Filed financial affidavit",
"action_required": "Schedule status conference or follow up with opposing counsel"
}
```
**See It In Action:**
Dashboard → "Victoria Case Insights" panel
***
## CaseMind™ Memory System
### Memory Extract (victoria-memory-extract)
**What It Does:**
Extracts structured facts from Victoria conversations and stores them in the CaseMind™ knowledge base for cross-agent intelligence sharing.
**Extracted Fact Types:**
* **Financial**: Income, assets, debts, property values
* **Procedural**: Court dates, filing deadlines, case status
* **Strategic**: Attorney recommendations, settlement positions
* **Personal**: Children's ages, custody preferences, special needs
* **Timeline**: Key events, separation dates, incidents
* **Discovery**: Document requests, production deadlines
* **Communication**: Important client statements, opposing party positions
**Key Features:**
* **Deduplication**: Prevents redundant facts (70% similarity threshold)
* **Entity Normalization**: Standardizes dates, amounts, names
* **Confidence Scoring**: 0-100 score for fact reliability
* **Automatic Conflict Detection**: Flags contradictory information
* **Retry Logic**: Resilient to API failures
**How It Works:**
1. Triggers automatically after Victoria chat responses
2. Claude Haiku 4.5 analyzes conversation for extractable facts
3. Stores facts in `victoria_case_memory` table with metadata
4. Makes facts available to all Victoria agents for future context
**Cost:** \~\$0.01-0.03 per extraction (Haiku 4.5)
### Memory Load (victoria-memory-load)
**What It Does:**
Retrieves relevant facts from CaseMind™ and injects them into Victoria's context for informed responses.
**Smart Context Assembly:**
* Filters facts by case\_id and relevance
* Prioritizes recent facts (last 90 days)
* Includes critical facts regardless of age
* Excludes superseded facts (marked inactive by Lifecycle Manager)
* Formats facts for optimal LLM comprehension
**Example Context Injection:**
```
CASEMIND MEMORY (Johnson v. Johnson):
• Husband's annual income: $125,000 (W-2, verified)
• Wife's annual income: $48,000 (self-employed, tax returns)
• Marital home value: $650,000 (appraisal dated 2024-10-15)
• Outstanding mortgage: $280,000
• 2 minor children: Emma (age 12), Lucas (age 9)
• Current custody: Wife has primary, husband weekends
• Separation date: 2024-03-15
```
***
## Background Extraction & Orchestration
### Background Orchestrator (victoria-background-orchestrator)
**What It Does:**
Enterprise-grade priority queue system for managing all background extraction jobs with cost controls, circuit breakers, and deduplication.
**Job Types:**
1. **case\_metadata**: Extract case numbers, party names, judges, courts
2. **casemind\_facts**: Extract legal facts and timeline events
3. **deadlines**: Extract court dates and filing deadlines
4. **tasks**: Extract action items and next steps
5. **embeddings**: Generate vector embeddings for semantic search
**Priority Levels:**
* **Critical**: Process immediately (e.g., deadline extraction)
* **High**: Process within 5 minutes (e.g., case metadata)
* **Medium**: Process within 15 minutes (e.g., CaseMind facts)
* **Low**: Process within 1 hour (e.g., embeddings)
**Enterprise Features:**
* **Per-Firm Budgets**: Monthly extraction quotas and cost limits
* **Deduplication Cache**: 24-hour TTL prevents duplicate jobs
* **Circuit Breakers**: Auto-pause on API rate limits
* **Retry Logic**: Exponential backoff (3 max attempts)
* **Cost Tracking**: Real-time spend monitoring per firm
**Database Table:** `background_extraction_jobs`
### Extraction Worker (victoria-extraction-worker)
**What It Does:**
Cron job that processes queued extraction jobs from the priority queue.
**Execution:**
* Runs every 2-5 minutes via Supabase Cron
* Processes up to 50 jobs per run (configurable batch size)
* Calls Background Orchestrator to execute jobs
* Reports metrics: processed count, queue size, processing time
**Monitoring:**
```sql theme={null}
SELECT
status,
COUNT(*) as count,
AVG(EXTRACT(EPOCH FROM (completed_at - created_at))) as avg_seconds
FROM background_extraction_jobs
WHERE created_at > NOW() - INTERVAL '24 hours'
GROUP BY status;
```
***
## Specialized Extractors
### Task Extractor (victoria-task-extractor)
**What It Does:**
Detects action items from Victoria conversations and creates tasks automatically.
**Detection Logic:**
* Looks for phrases like "you should," "next step," "make sure to"
* Identifies explicit action items in attorney-Victoria chats
* Extracts due dates and assigns to appropriate users
* Categorizes tasks: discovery, filing, client communication, investigation
**Auto-Created Task Example:**
```
Title: "File Motion to Modify Support"
Description: "Victoria recommended filing motion due to husband's income change ($125K → $95K)"
Due Date: 2025-02-15 (30 days from conversation)
Assigned To: Attorney handling case
Priority: High
```
### Deadline Extractor (victoria-deadline-extractor)
**What It Does:**
Extracts court dates, filing deadlines, and discovery cutoffs from conversations and documents.
**Detected Deadline Types:**
* Court hearings and trials
* Discovery cutoffs (interrogatories, requests for production)
* Financial disclosure deadlines
* Response deadlines (motions, pleadings)
* Mediation and settlement conferences
**Smart Detection:**
* Recognizes jurisdiction-specific rules (e.g., Florida's 45-day financial disclosure)
* Calculates response deadlines automatically
* Creates calendar events with reminders
* Flags conflicts with existing deadlines
### Case Metadata Extract (victoria-case-metadata-extract)
**What It Does:**
Extracts structured case information from uploaded documents and conversations.
**Extracted Metadata:**
* **Case Number**: Court-assigned case identifier
* **Parties**: Petitioner, respondent, children names/ages
* **Court Information**: Judge name, courtroom, jurisdiction
* **Case Type**: Dissolution, modification, contempt, paternity
* **Attorney Information**: Opposing counsel, their firm
**Auto-Population:**
Extracted metadata automatically populates case fields, reducing manual data entry by \~80%.
### Financial Affidavit Extract (victoria-financial-affidavit-extract)
**What It Does:**
Extracts financial data from uploaded affidavits (Form 12.902, Form 13, etc.) using Claude's vision capabilities.
**Extracted Data:**
* Income (W-2, self-employment, bonuses, etc.)
* Assets (bank accounts, investments, real property, vehicles)
* Liabilities (mortgages, credit cards, loans)
* Monthly expenses (housing, utilities, childcare, etc.)
**Accuracy:** 95%+ for clean PDFs with standard court forms
***
## Lifecycle Management
### Lifecycle Manager (victoria-lifecycle-manager)
**What It Does:**
Intelligent lifecycle management for all 3 AI systems: CaseMind, Task Manager, and Deadline Manager.
**Auto-Complete Tasks:**
Detects task completion from CaseMind facts using fuzzy matching:
* Compares pending tasks to recent facts (last 7 days)
* 70% similarity threshold for auto-completion
* Marks task as completed with source fact reference
**Example:**
* Task: "File financial affidavit"
* Fact Detected: "Uploaded Florida Financial Affidavit (Form 12.902(c)) on 2025-01-15"
* **Result**: Task auto-completed ✅
**Auto-Archive Deadlines:**
Archives past deadlines after 90 days to reduce clutter.
**Supersede Facts:**
Marks outdated facts as `is_superseded = true` when newer conflicting facts are detected:
* Asset value updates
* Income changes
* Address changes
**Runs:** After every Victoria response (triggered by victoria-co-counsel, victoria-discovery, victoria-financial)
***
## Routing & Coordination
### Orchestrator (victoria-orchestrator)
**What It Does:**
Routes incoming requests to the appropriate Victoria agent based on intent detection.
**Routing Logic:**
1. Analyzes user question with Claude Haiku 4.5 (fast, cheap)
2. Detects intent: legal strategy → Co-Counsel, financial → Financial Analyst, discovery → Discovery Manager
3. Routes to specialized agent with full context
4. Returns response to user
**Cost Optimization:**
* Uses Haiku 4.5 for routing (\~\$0.002 per request)
* Prevents unnecessary expensive model calls
* \~95% routing accuracy
### Question Router (victoria-question-router)
**What It Does:**
Routes client questions from Client Portal to appropriate handlers (Victoria Client Liaison vs attorney escalation).
**Routing Decision:**
* **General questions** → Victoria Client Liaison (e.g., "What is community property?")
* **Case-specific legal advice** → Attorney escalation (e.g., "Should I accept this settlement offer?")
* **Sensitive issues** → Attorney escalation (e.g., domestic violence, complex custody)
***
## Utility Functions
### Context Injector (victoria-context-injector)
**What It Does:**
Replaces placeholders in Victoria's system prompts with dynamic case-specific context.
**Supported Placeholders:**
* `{{FINANCIAL_DISCLOSURE_RULE}}` → Jurisdiction-specific rule (e.g., Florida Rule 12.285)
* `{{FINANCIAL_DISCLOSURE_DEADLINE}}` → Deadline calculation (e.g., 45 days from service)
* `{{FINANCIAL_DISCLOSURE_CONSEQUENCES}}` → Penalties for non-compliance
* `{{FINANCIAL_DISCLOSURE_FORMS}}` → Required forms (e.g., Form 12.902(b) or 12.902(c))
* `{{CASEMIND_CONTEXT}}` → Recent facts from CaseMind
* `{{JURISDICTION_RULES}}` → Practice knowledge for case jurisdiction
**Result:** Hyper-personalized prompts that adapt to each case's jurisdiction, facts, and needs.
### Billing Log (victoria-billing-log)
**What It Does:**
Tracks AI usage costs and logs them to `ai_usage_logs` table for billing transparency.
**Logged Metrics:**
* Tokens used (input/output)
* Model used (Haiku/Sonnet/Opus)
* Cost calculation (based on Anthropic pricing)
* Victoria mode (co\_counsel, discovery, financial\_analyst, etc.)
* Case ID, firm ID, user ID attribution
* Timestamp and feature type
**Billing Reports:**
```sql theme={null}
SELECT
victoria_mode,
COUNT(*) as interactions,
SUM(total_tokens) as tokens,
SUM(billable_cost) as cost
FROM ai_usage_logs
WHERE firm_id = 'YOUR_FIRM_ID'
AND created_at > '2025-01-01'
GROUP BY victoria_mode;
```
***
## Cost & Performance Metrics
### Backend AI Cost Breakdown
| Function | Model | Avg Cost/Run | Frequency |
| ---------------------- | --------- | ------------ | ------------------------------------ |
| Case Insights | Haiku 4.5 | \$0.03-0.08 | Once per dashboard load (24hr cache) |
| Memory Extract | Haiku 4.5 | \$0.01-0.03 | After every Victoria chat |
| Task Extractor | Haiku 4.5 | \$0.01-0.02 | After chats with action items |
| Deadline Extractor | Haiku 4.5 | \$0.01-0.02 | When dates mentioned |
| Case Metadata | Haiku 4.5 | \$0.02-0.05 | Per document upload |
| Orchestrator (Routing) | Haiku 4.5 | \$0.002 | Every Victoria request |
**Monthly Estimate** (for average firm with 50 active cases):
* Case Insights: \~$2.40/month ($0.08 × 30 days)
* Memory Extraction: \~$15/month ($0.02 × 25 chats/day × 30 days)
* Task/Deadline Extraction: \~\$5/month
* Routing: \~\$3/month
**Total Backend AI**: \~\$25.40/month per firm (for 50 cases, 25 chats/day)
### Performance Metrics
| Function | Avg Execution Time | Success Rate |
| ----------------- | ------------------ | ------------ |
| Memory Extract | 2-4 seconds | 99.2% |
| Case Insights | 8-12 seconds | 98.5% |
| Task Extractor | 1-3 seconds | 97.8% |
| Orchestrator | 200-400ms | 99.9% |
| Lifecycle Manager | 3-6 seconds | 98.9% |
***
## Monitoring & Debugging
### Database Tables
**Primary Tables:**
* `victoria_case_memory` - CaseMind™ extracted facts
* `background_extraction_jobs` - Queue for all extraction jobs
* `case_manager_insights` - Cached case insights (24hr TTL)
* `ai_usage_logs` - Cost tracking and usage metrics
* `tasks` - Auto-generated and manual tasks
* `deadlines` - Court dates and filing deadlines
### SQL Monitoring Queries
**Check Extraction Queue:**
```sql theme={null}
SELECT
job_type,
priority,
status,
COUNT(*) as count
FROM background_extraction_jobs
WHERE created_at > NOW() - INTERVAL '1 hour'
GROUP BY job_type, priority, status
ORDER BY priority DESC, job_type;
```
**CaseMind Fact Count by Case:**
```sql theme={null}
SELECT
c.title as case_title,
COUNT(m.id) as fact_count,
MAX(m.created_at) as latest_fact
FROM cases c
LEFT JOIN victoria_case_memory m ON m.case_id = c.id
WHERE c.firm_id = 'YOUR_FIRM_ID'
GROUP BY c.id, c.title
ORDER BY fact_count DESC;
```
**Backend AI Cost Analysis:**
```sql theme={null}
SELECT
DATE(created_at) as date,
feature_type,
SUM(billable_cost) as daily_cost,
COUNT(*) as executions
FROM ai_usage_logs
WHERE firm_id = 'YOUR_FIRM_ID'
AND created_at > NOW() - INTERVAL '30 days'
AND feature_type IN ('casemind_extraction', 'case_insights', 'task_extraction', 'deadline_extraction')
GROUP BY DATE(created_at), feature_type
ORDER BY date DESC, daily_cost DESC;
```
***
## Technical Architecture
### Event-Driven Design
Backend AI functions use an event-driven architecture:
```
User Action (Chat/Upload)
↓
Main Agent Response (Co-Counsel/Discovery/Financial)
↓
Queue Extraction Jobs (via Background Orchestrator)
↓
Extraction Worker (Cron job every 2-5 min)
↓
Execute Jobs (Memory Extract, Task Extract, etc.)
↓
Update Database (victoria_case_memory, tasks, deadlines)
↓
Available for Next Agent (via Memory Load, Context Injector)
```
### Caching Strategy
* **Case Insights**: 24-hour cache (expires\_at column)
* **Practice Knowledge**: 5-minute prompt cache (Anthropic)
* **Deduplication**: 24-hour hash cache (prevents duplicate jobs)
* **Memory Facts**: No expiration (marked superseded instead)
### Error Handling
* **Retry Logic**: 3 attempts with exponential backoff (2s, 4s, 8s)
* **Circuit Breakers**: Auto-pause on 5 consecutive failures
* **Fallback**: Graceful degradation (skip extraction if failed)
* **Monitoring**: All errors logged to `ai_usage_logs` with status='failed'
***
## Next Steps
Learn how Victoria remembers everything
Explore the 4 interactive Victoria agents
Advanced cost optimization techniques
Integrate backend AI into your workflows