graph-flow

The Insurance Claims Workflow is a modular task-based system designed for processing insurance claims. It uses conditional routing to handle different insurance types and claim amounts.

Workflow Flow:

1. Initial Claim Query: Gathers initial information.
2. Insurance Type Classifier: Routes the workflow to either Car or Apartment insurance paths.
3. Insurance Details: Collects specific details based on the type (Car or Apartment).
4. Smart Claim Validator & Approval Handler:
   • Claims < $1000: Automatically approved.
   • Claims ≥ $1000: Requires manual approval/decision before proceeding.
5. Final Summary: The terminal endpoint that provides the outcome (Approved or Rejected).

Initial Claim Query
       ↓
Insurance Type Classifier
       ↓
    [Car | Apartment] Insurance Details
       ↓
Smart Claim Validator & Approval Handler
  (Auto-approve <$1000 OR Wait for manual approval ≥$1000)
       ↓
   Final Summary
  (Approved OR Rejected)

The service uses a multi-step workflow orchestrated by graph-flow to ensure high-quality recommendations. The process follows these stages:

1. Query Refinement (QueryRefinementTask): Uses an LLM to rewrite the user's raw query into a semantically optimized version for vector search.
2. Vector Search (VectorSearchTask): Generates embeddings for the refined query and performs a similarity search against the movies_with_vectors table, retrieving the top N movies (default 25).
3. Answer Generation (AnswerGenerationTask): Uses the retrieved movie context and conversation history to generate a natural language recommendation using OpenRouter/GPT-4o-mini.
4. Validation (ValidationTask): An LLM evaluates the generated answer for quality. If the answer is insufficient, it provides feedback.
5. Retry Logic: If validation fails, the service automatically retries the generation (up to MAX_RETRIES times) using the validation feedback and chat history.
6. Delivery (DeliveryTask): Returns the final validated recommendation and logs completion statistics.

The Context is a thread-safe, typed, and serialized key-value store used to pass data between tasks and maintain session state.

Key capabilities:

• Typed Storage: Use .set(key, value)? and .get::<T>(key) for type-safe state management. Note that .set() is fallible due to potential serialization errors.
• Chat History: Built-in support for LLM conversation history via .add_user_message(string) and .add_assistant_message(string). History is stored in a ring buffer (default cap: 1000 messages).
• Synchronous API: All Context methods are synchronous, making them safe to use in both async tasks and synchronous edge-condition closures.

// Typed key-value state; set() is fallible (serialization can fail)
context.set("claim_amount", 1500.0)?;
let amount: f64 = context.get::<f64>("claim_amount").unwrap();

// Works directly in edge conditions
let ok = context.get::<bool>("condition").unwrap_or(false);

// Built-in chat history (ring buffer, capped at 1000 messages by default)
context.add_user_message("What's my claim status?".to_string());
context.add_assistant_message("Your claim is being processed".to_string());
let recent = context.get_last_messages(5);

The Movie Recommendation Service is an Axum-based web service that provides AI-powered movie recommendations using a multi-step workflow. It requires two PostgreSQL databases: one for session state and one for movie data with vector embeddings.

Prerequisites

• PostgreSQL with pgvector extension installed.
• An OpenRouter API key.

Environment Variables

You must configure the following environment variables:

Database Schema Setup

Run the following SQL to prepare the movies database:

CREATE TABLE movies_with_vectors (
    id SERIAL PRIMARY KEY,
    title TEXT NOT NULL,
    overview TEXT,
    vector vector(384)  -- Adjust dimension based on your embedding model
);

-- Add vector similarity search index
CREATE INDEX movies_vector_idx ON movies_with_vectors USING ivfflat (vector vector_cosine_ops);

# Install dependencies
cargo build

# Set environment variables
export DATABASE_URL="postgresql://user:password@localhost:5432/sessions_db"
export MOVIES_DATABASE_URL="postgresql://user:password@localhost:5432/movies_db"
export OPENROUTER_API_KEY="your_api_key"

# Run the service
cargo run