diff --git a/.env.example b/.env.example
index ec66fc0..c9e31a8 100644
--- a/.env.example
+++ b/.env.example
@@ -1,4 +1,17 @@
-# To separate your traces from other application
-LANGSMITH_PROJECT=new-agent
+# LangSmith Configuration
+# To separate your traces from other applications
+LANGSMITH_PROJECT=voicedform
+# LANGCHAIN_TRACING_V2=true
+# LANGCHAIN_API_KEY=your_langsmith_api_key
 
-# Add API keys for connecting to LLM providers, data sources, and other integrations here
+# LLM Provider API Keys
+# OpenAI API key for GPT-4 and LangGraph workflow
+OPENAI_API_KEY=sk-your-openai-api-key-here
+
+# Whisper Modal Server Configuration
+# URL of your deployed Modal Whisper API
+# Get this after running: modal deploy modal_whisper_server.py
+# Example: https://username--voicedform-whisper-fastapi-app.modal.run
+WHISPER_API_URL=https://your-modal-whisper-url.modal.run
+
+# Add additional API keys for other integrations here
diff --git a/Makefile b/Makefile
index 4bfd878..a79409a 100644
--- a/Makefile
+++ b/Makefile
@@ -1,4 +1,4 @@
-.PHONY: all format lint test tests test_watch integration_tests docker_tests help extended_tests
+.PHONY: all format lint test tests test_watch integration_tests docker_tests help extended_tests whisper_deploy whisper_serve whisper_test
 
 # Default target executed when no arguments are given to make.
 all: help
@@ -52,6 +52,22 @@ spell_check:
 spell_fix:
 	codespell --toml pyproject.toml -w
 
+######################
+# WHISPER MODAL SERVER
+######################
+
+whisper_deploy:
+	modal deploy modal_whisper_server.py
+
+whisper_serve:
+	modal serve modal_whisper_server.py
+
+whisper_test:
+	python -m pytest tests/test_whisper_integration.py -v
+
+whisper_examples:
+	python examples/whisper_usage_examples.py
+
 ######################
 # HELP
 ######################
@@ -64,4 +80,8 @@ help:
 	@echo 'tests                        - run unit tests'
 	@echo 'test TEST_FILE=<test_file>   - run all tests in file'
 	@echo 'test_watch                   - run unit tests in watch mode'
+	@echo 'whisper_deploy               - deploy Whisper server to Modal (production)'
+	@echo 'whisper_serve                - run Whisper server in development mode'
+	@echo 'whisper_test                 - run Whisper integration tests'
+	@echo 'whisper_examples             - run Whisper usage examples'
 
diff --git a/README_VOICEDFORM.md b/README_VOICEDFORM.md
new file mode 100644
index 0000000..8f158da
--- /dev/null
+++ b/README_VOICEDFORM.md
@@ -0,0 +1,381 @@
+# VoicedForm 🎙️
+
+> Voice-driven form completion powered by LangGraph and OpenAI Whisper
+
+[![CI](https://github.com/langchain-ai/new-langgraph-project/actions/workflows/unit-tests.yml/badge.svg)](https://github.com/langchain-ai/new-langgraph-project/actions/workflows/unit-tests.yml)
+[![Integration Tests](https://github.com/langchain-ai/new-langgraph-project/actions/workflows/integration-tests.yml/badge.svg)](https://github.com/langchain-ai/new-langgraph-project/actions/workflows/integration-tests.yml)
+
+VoicedForm is an intelligent voice-driven form completion system built with [LangGraph](https://github.com/langchain-ai/langgraph). It uses AI agents to help users complete forms through natural conversational interaction - either by voice or text.
+
+## Features
+
+- **Voice Input**: Transcribe speech to text using OpenAI Whisper on Modal
+- **Intelligent Form Detection**: Automatically determines form type from user input
+- **AI-Powered Completion**: Uses GPT-4 to extract and organize form data
+- **LangGraph Workflow**: Multi-node workflow with supervisor pattern
+- **Serverless Deployment**: Whisper runs on Modal's GPU infrastructure
+- **Flexible Input**: Supports both voice and text input
+
+## Architecture
+
+```
+┌─────────────┐
+│ User Input  │
+│ (Voice/Text)│
+└──────┬──────┘
+       │
+       ▼
+┌──────────────────┐
+│ Audio            │
+│ Transcription    │  ← Whisper on Modal
+└────────┬─────────┘
+         │
+         ▼
+┌────────────────────────────────────────┐
+│          LangGraph Workflow            │
+│  ┌──────────┐  ┌──────────────┐       │
+│  │Supervisor│→ │Form Selector │       │
+│  └──────────┘  └──────┬───────┘       │
+│                       │                │
+│  ┌──────────────┐  ┌─▼──────────┐     │
+│  │  Validator   │← │Form Complete│     │
+│  └──────────────┘  └────────────┘     │
+└────────────────────────────────────────┘
+         │
+         ▼
+┌──────────────────┐
+│ Completed Form   │
+└──────────────────┘
+```
+
+## Quick Start
+
+### 1. Install Dependencies
+
+```bash
+# Clone repository
+git clone https://github.com/jojopeligroso/VoicedForm.git
+cd VoicedForm
+
+# Install Python dependencies
+pip install -e .
+pip install modal httpx
+
+# Authenticate with Modal
+modal setup
+```
+
+### 2. Configure Environment
+
+```bash
+# Copy example environment file
+cp .env.example .env
+
+# Edit .env and add your API keys
+# OPENAI_API_KEY=sk-...
+# WHISPER_API_URL=<will be set after Modal deployment>
+```
+
+### 3. Deploy Whisper Server
+
+```bash
+# Deploy to Modal (first time)
+modal deploy modal_whisper_server.py
+
+# Copy the Web endpoint URL and add to .env
+# WHISPER_API_URL=https://your-workspace--voicedform-whisper-fastapi-app.modal.run
+```
+
+### 4. Run VoicedForm
+
+```bash
+# Run with voice input
+python voicedform_graph_with_audio.py your_audio_file.mp3
+
+# Or run with text input
+python voicedform_graph_with_audio.py
+```
+
+## Project Structure
+
+```
+VoicedForm/
+├── modal_whisper_server.py           # Whisper server on Modal
+├── src/
+│   ├── agent/                        # LangGraph agent template
+│   └── whisper_client.py             # Whisper API client
+├── voicedform_graph.py               # Original graph (text only)
+├── voicedform_graph_with_audio.py    # Enhanced graph with audio
+├── examples/
+│   └── whisper_usage_examples.py     # Usage examples
+├── tests/
+│   ├── unit_tests/                   # Unit tests
+│   ├── integration_tests/            # Integration tests
+│   └── test_whisper_integration.py   # Whisper tests
+├── WHISPER_README.md                 # Whisper integration docs
+├── WHISPER_DEPLOYMENT.md             # Deployment guide
+└── README.md                         # This file
+```
+
+## Usage
+
+### Voice Input Example
+
+```python
+from voicedform_graph_with_audio import process_voice_input
+
+# Process voice recording
+result = process_voice_input("accident_report.mp3")
+
+print(f"Transcribed: {result['transcribed_text']}")
+print(f"Form Type: {result['form_type']}")
+print(f"Completed Form:\n{result['form_complete']}")
+```
+
+### Text Input Example
+
+```python
+from voicedform_graph_with_audio import process_text_input
+
+# Process text directly
+result = process_text_input(
+    "I need to report an accident on Main Street today at 2pm"
+)
+
+print(f"Form Type: {result['form_type']}")
+print(f"Completed Form:\n{result['form_complete']}")
+```
+
+### Using Whisper Client Directly
+
+```python
+from src.whisper_client import WhisperClient
+
+client = WhisperClient()
+result = client.transcribe("audio.mp3", language="en")
+
+if result.success:
+    print(f"Transcription: {result.text}")
+    print(f"Language: {result.language}")
+```
+
+## Documentation
+
+- **[WHISPER_README.md](WHISPER_README.md)** - Whisper integration overview and API reference
+- **[WHISPER_DEPLOYMENT.md](WHISPER_DEPLOYMENT.md)** - Comprehensive deployment guide
+- **[examples/whisper_usage_examples.py](examples/whisper_usage_examples.py)** - 10+ usage examples
+
+## Development
+
+### Running Tests
+
+```bash
+# Install test dependencies
+pip install pytest pytest-asyncio
+
+# Run unit tests
+pytest tests/unit_tests -v
+
+# Run integration tests
+pytest tests/integration_tests -v
+
+# Run Whisper integration tests
+pytest tests/test_whisper_integration.py -v
+```
+
+### Development with LangGraph Studio
+
+```bash
+# Start LangGraph dev server
+langgraph dev
+```
+
+Open [LangGraph Studio](https://langchain-ai.github.io/langgraph/concepts/langgraph_studio/) to visualize and debug your workflow.
+
+### Hot Reload
+
+Local changes to graph files are automatically applied via hot reload while LangGraph Studio is running.
+
+## Configuration
+
+### Environment Variables
+
+| Variable | Description | Required |
+|----------|-------------|----------|
+| `OPENAI_API_KEY` | OpenAI API key for GPT-4 | Yes |
+| `WHISPER_API_URL` | Modal Whisper API endpoint | Yes |
+| `LANGSMITH_PROJECT` | LangSmith project name | No |
+| `LANGCHAIN_TRACING_V2` | Enable LangSmith tracing | No |
+| `LANGCHAIN_API_KEY` | LangSmith API key | No |
+
+### Whisper Configuration
+
+Edit `modal_whisper_server.py` to customize:
+
+```python
+# Model size (tiny, base, small, medium, large)
+model_size: str = "base"
+
+# GPU type (affects cost and speed)
+GPU_CONFIG = modal.gpu.A10G()
+
+# Container timeout (affects cost)
+container_idle_timeout=300  # 5 minutes
+```
+
+## How It Works
+
+### 1. Audio Transcription (Optional)
+
+If audio input is provided, the Whisper Modal server transcribes it to text:
+
+```python
+def audio_transcription_node(state):
+    result = whisper_client.transcribe(state["audio_file"])
+    return {"transcribed_text": result.text, "user_input": result.text}
+```
+
+### 2. Supervisor
+
+Analyzes user input to determine form type:
+
+```python
+def supervisor_node(state):
+    form_type = llm.invoke(f"Determine form type for: {state['user_input']}")
+    return {"form_type": form_type}
+```
+
+### 3. Form Selector
+
+Identifies required fields for the form:
+
+```python
+def form_selector_node(state):
+    fields = llm.invoke(f"List required fields for {state['form_type']}")
+    return {"form_fields": fields}
+```
+
+### 4. Form Completion
+
+Extracts data from user input and populates form:
+
+```python
+def form_completion_node(state):
+    completed = llm.invoke(f"Fill form with: {state['user_input']}")
+    return {"form_complete": completed}
+```
+
+### 5. Validator
+
+Verifies form is properly completed:
+
+```python
+def validator_node(state):
+    is_valid = check_form_complete(state["form_complete"])
+    return {"valid": is_valid}
+```
+
+## Deployment
+
+### Modal Deployment
+
+```bash
+# Development deployment (with live reload)
+modal serve modal_whisper_server.py
+
+# Production deployment
+modal deploy modal_whisper_server.py
+```
+
+### Cost Estimation
+
+Based on typical usage (100 transcriptions/day, 1 min each, base model):
+
+- **GPU Time**: ~$0.13/day
+- **Storage**: <$0.10/month
+- **Monthly Total**: ~$5-10
+
+See [WHISPER_DEPLOYMENT.md](WHISPER_DEPLOYMENT.md) for detailed cost optimization strategies.
+
+## Examples
+
+See [examples/whisper_usage_examples.py](examples/whisper_usage_examples.py) for comprehensive examples including:
+
+1. Basic transcription
+2. Language specification
+3. Different model sizes
+4. Translation to English
+5. Context-aware transcription
+6. Segment-level analysis
+7. Async transcription
+8. Error handling
+9. VoicedForm integration
+
+## Troubleshooting
+
+### Common Issues
+
+**"No API URL configured"**
+```bash
+export WHISPER_API_URL="https://your-modal-url.modal.run"
+```
+
+**"Modal authentication failed"**
+```bash
+modal setup
+```
+
+**Slow transcription**
+- Use smaller model (`model_size="tiny"`)
+- Specify language (`language="en"`)
+- Upgrade GPU (`GPU_CONFIG = modal.gpu.A100()`)
+
+See [WHISPER_DEPLOYMENT.md](WHISPER_DEPLOYMENT.md) for complete troubleshooting guide.
+
+## Performance
+
+| Model | Cold Start | Warm Start | 1 min Audio |
+|-------|-----------|------------|-------------|
+| tiny  | ~3s       | <100ms     | ~2s         |
+| base  | ~4s       | <100ms     | ~4s         |
+| small | ~6s       | <100ms     | ~8s         |
+| medium| ~10s      | <100ms     | ~15s        |
+| large | ~15s      | <100ms     | ~30s        |
+
+## Contributing
+
+Contributions welcome! Please:
+
+1. Fork the repository
+2. Create a feature branch
+3. Add tests for new features
+4. Submit a pull request
+
+## Resources
+
+- **[LangGraph Documentation](https://langchain-ai.github.io/langgraph/)**
+- **[Modal Documentation](https://modal.com/docs)**
+- **[OpenAI Whisper](https://github.com/openai/whisper)**
+- **[LangGraph Studio](https://langchain-ai.github.io/langgraph/concepts/langgraph_studio/)**
+- **[LangSmith](https://smith.langchain.com/)**
+
+## License
+
+MIT License - see LICENSE file for details
+
+## Acknowledgments
+
+- Built with [LangGraph](https://github.com/langchain-ai/langgraph)
+- Powered by [OpenAI Whisper](https://github.com/openai/whisper)
+- Deployed on [Modal](https://modal.com)
+- Based on LangChain's [new-langgraph-project](https://github.com/langchain-ai/new-langgraph-project) template
+
+## Support
+
+- **Issues**: [GitHub Issues](https://github.com/jojopeligroso/VoicedForm/issues)
+- **Discussions**: [GitHub Discussions](https://github.com/jojopeligroso/VoicedForm/discussions)
+- **Documentation**: See `WHISPER_DEPLOYMENT.md` and `WHISPER_README.md`
+
+---
+
+Made with ❤️ by the VoicedForm team
diff --git a/SETUP_GUIDE.md b/SETUP_GUIDE.md
new file mode 100644
index 0000000..bad860a
--- /dev/null
+++ b/SETUP_GUIDE.md
@@ -0,0 +1,301 @@
+# VoicedForm Setup Guide
+
+This guide will help you get VoicedForm up and running with Whisper speech-to-text capabilities in under 10 minutes.
+
+## Prerequisites
+
+Before you begin, ensure you have:
+
+- Python 3.9 or higher
+- pip or uv package manager
+- OpenAI API key ([get one here](https://platform.openai.com/api-keys))
+- Modal account ([sign up here](https://modal.com))
+
+## Step-by-Step Setup
+
+### 1. Clone and Install (2 minutes)
+
+```bash
+# Clone the repository
+git clone https://github.com/jojopeligroso/VoicedForm.git
+cd VoicedForm
+
+# Install dependencies
+pip install -e .
+
+# Install Modal and HTTP client
+pip install modal httpx
+```
+
+### 2. Configure Modal (1 minute)
+
+```bash
+# Authenticate with Modal (opens browser)
+modal setup
+```
+
+Follow the prompts to authenticate. This creates a Modal token in `~/.modal.toml`.
+
+### 3. Deploy Whisper Server (3 minutes)
+
+```bash
+# Deploy to Modal
+make whisper_deploy
+
+# Or manually:
+# modal deploy modal_whisper_server.py
+```
+
+You'll see output like:
+
+```
+✓ Created deployment d-1234567890
+View deployment: https://modal.com/apps/your-workspace/voicedform-whisper
+
+Web endpoint: https://your-workspace--voicedform-whisper-fastapi-app.modal.run
+```
+
+**Important**: Copy the `Web endpoint` URL - you'll need it in the next step!
+
+### 4. Configure Environment (1 minute)
+
+```bash
+# Copy example environment file
+cp .env.example .env
+
+# Edit .env file
+nano .env  # or use your preferred editor
+```
+
+Add your API keys:
+
+```bash
+# Required
+OPENAI_API_KEY=sk-your-openai-key-here
+WHISPER_API_URL=https://your-workspace--voicedform-whisper-fastapi-app.modal.run
+
+# Optional (for LangSmith tracing)
+LANGSMITH_PROJECT=voicedform
+# LANGCHAIN_TRACING_V2=true
+# LANGCHAIN_API_KEY=your-langsmith-key
+```
+
+### 5. Test Everything (2 minutes)
+
+```bash
+# Test 1: Check Modal deployment
+curl https://your-workspace--voicedform-whisper-fastapi-app.modal.run/health
+
+# Expected response: {"status":"healthy","service":"whisper-api"}
+
+# Test 2: Run Whisper integration tests
+make whisper_test
+
+# Test 3: Run usage examples
+make whisper_examples
+```
+
+## Verify Installation
+
+Run this quick verification script:
+
+```python
+# verify_setup.py
+import os
+from dotenv import load_dotenv
+from src.whisper_client import WhisperClient
+
+load_dotenv()
+
+print("Checking VoicedForm setup...")
+print("-" * 50)
+
+# Check environment variables
+openai_key = os.getenv("OPENAI_API_KEY")
+whisper_url = os.getenv("WHISPER_API_URL")
+
+print(f"✓ OPENAI_API_KEY: {'Set' if openai_key else 'NOT SET'}")
+print(f"✓ WHISPER_API_URL: {'Set' if whisper_url else 'NOT SET'}")
+
+# Check Whisper API health
+if whisper_url:
+    client = WhisperClient()
+    if client.health_check():
+        print("✓ Whisper API: Healthy")
+    else:
+        print("✗ Whisper API: Not accessible")
+else:
+    print("✗ Whisper API: URL not configured")
+
+print("-" * 50)
+print("Setup verification complete!")
+```
+
+Run it:
+
+```bash
+python verify_setup.py
+```
+
+Expected output:
+
+```
+Checking VoicedForm setup...
+--------------------------------------------------
+✓ OPENAI_API_KEY: Set
+✓ WHISPER_API_URL: Set
+✓ Whisper API: Healthy
+--------------------------------------------------
+Setup verification complete!
+```
+
+## Quick Usage Examples
+
+### Example 1: Transcribe Audio
+
+```python
+from src.whisper_client import transcribe
+
+# Simple one-liner
+result = transcribe("your_audio.mp3", language="en")
+print(result.text)
+```
+
+### Example 2: Complete Form with Voice
+
+```python
+from voicedform_graph_with_audio import process_voice_input
+
+# Process voice input through full workflow
+result = process_voice_input("accident_report.mp3")
+
+print(f"Transcribed: {result['transcribed_text']}")
+print(f"Form Type: {result['form_type']}")
+print(f"Form:\n{result['form_complete']}")
+```
+
+### Example 3: Complete Form with Text
+
+```python
+from voicedform_graph_with_audio import process_text_input
+
+# Process text input (no transcription needed)
+result = process_text_input(
+    "I need to report a car accident on Main Street at 2pm today"
+)
+
+print(f"Form:\n{result['form_complete']}")
+```
+
+## Common Issues
+
+### Issue: "Modal not found"
+
+**Solution**:
+```bash
+pip install modal
+```
+
+### Issue: "WHISPER_API_URL not set"
+
+**Solution**: Make sure you copied the Web endpoint URL from Modal deployment and added it to `.env`:
+
+```bash
+# In .env file
+WHISPER_API_URL=https://your-workspace--voicedform-whisper-fastapi-app.modal.run
+```
+
+### Issue: "Whisper API not accessible"
+
+**Solution**: Verify deployment is active:
+
+```bash
+modal app list
+modal app describe voicedform-whisper
+```
+
+If not listed, redeploy:
+
+```bash
+make whisper_deploy
+```
+
+### Issue: "OpenAI API key invalid"
+
+**Solution**: Get a new API key from https://platform.openai.com/api-keys and update `.env`.
+
+### Issue: "Audio file not found"
+
+**Solution**: Provide full path to audio file:
+
+```python
+result = transcribe("/full/path/to/audio.mp3")
+```
+
+## Next Steps
+
+Now that you're set up, explore:
+
+1. **[WHISPER_README.md](WHISPER_README.md)** - Complete API reference and examples
+2. **[WHISPER_DEPLOYMENT.md](WHISPER_DEPLOYMENT.md)** - Advanced deployment options
+3. **[examples/whisper_usage_examples.py](examples/whisper_usage_examples.py)** - 10+ usage examples
+4. **[tests/test_whisper_integration.py](tests/test_whisper_integration.py)** - Integration tests
+
+## Development Workflow
+
+```bash
+# Make code changes
+vim voicedform_graph_with_audio.py
+
+# Run tests
+make test
+make whisper_test
+
+# Deploy updated Whisper server
+make whisper_deploy
+
+# Format code
+make format
+
+# Lint code
+make lint
+```
+
+## Getting Help
+
+- **Documentation**: See `WHISPER_README.md` and `WHISPER_DEPLOYMENT.md`
+- **Examples**: Run `make whisper_examples`
+- **Tests**: Run `make whisper_test`
+- **Issues**: https://github.com/jojopeligroso/VoicedForm/issues
+
+## Cost Estimate
+
+With typical usage (100 transcriptions/day, 1 min audio each):
+
+- **Whisper on Modal**: ~$5-10/month
+- **OpenAI GPT-4**: Depends on form complexity (~$10-30/month for moderate use)
+- **Total**: ~$15-40/month
+
+First-time users get **$30 free credits** on Modal!
+
+## Uninstall
+
+To remove VoicedForm:
+
+```bash
+# Delete Modal deployment
+modal app delete voicedform-whisper
+
+# Remove Python package
+pip uninstall agent
+
+# Delete repository
+cd ..
+rm -rf VoicedForm
+```
+
+---
+
+**Setup complete!** You're ready to use VoicedForm for voice-driven form completion.
+
+For questions or issues, see the [troubleshooting guide](WHISPER_DEPLOYMENT.md#troubleshooting) or [open an issue](https://github.com/jojopeligroso/VoicedForm/issues).
diff --git a/WHISPER_DEPLOYMENT.md b/WHISPER_DEPLOYMENT.md
new file mode 100644
index 0000000..0a45bcc
--- /dev/null
+++ b/WHISPER_DEPLOYMENT.md
@@ -0,0 +1,553 @@
+# Whisper Deployment Guide for VoicedForm
+
+This guide covers everything you need to deploy and use the Modal Whisper server for speech-to-text transcription in VoicedForm.
+
+## Table of Contents
+
+- [Overview](#overview)
+- [Prerequisites](#prerequisites)
+- [Quick Start](#quick-start)
+- [Deployment Steps](#deployment-steps)
+- [Usage](#usage)
+- [Configuration](#configuration)
+- [Testing](#testing)
+- [Monitoring & Debugging](#monitoring--debugging)
+- [Cost Optimization](#cost-optimization)
+- [Troubleshooting](#troubleshooting)
+
+## Overview
+
+The VoicedForm Whisper integration provides serverless speech-to-text capabilities using:
+
+- **Modal**: Serverless GPU infrastructure for running Whisper
+- **OpenAI Whisper**: State-of-the-art speech recognition model
+- **FastAPI**: REST API for easy integration
+- **LangGraph**: Integration with form completion workflow
+
+### Architecture
+
+```
+┌─────────────┐
+│ User Audio  │
+└──────┬──────┘
+       │
+       ▼
+┌──────────────────────┐
+│  VoicedForm Client   │
+│  (whisper_client.py) │
+└──────┬───────────────┘
+       │ HTTP/gRPC
+       ▼
+┌──────────────────────┐
+│  Modal Whisper API   │
+│  (GPU-accelerated)   │
+└──────┬───────────────┘
+       │
+       ▼
+┌──────────────────────┐
+│ LangGraph Workflow   │
+│ (Form Completion)    │
+└──────────────────────┘
+```
+
+## Prerequisites
+
+### 1. Modal Account
+
+Sign up for a Modal account at https://modal.com
+
+```bash
+# Install Modal CLI
+pip install modal
+
+# Authenticate (opens browser)
+modal setup
+```
+
+### 2. Python Environment
+
+- Python 3.9 or higher
+- pip or uv package manager
+
+### 3. Required API Keys
+
+- **Modal Token**: Automatically configured via `modal setup`
+- **OpenAI API Key**: For LangGraph workflow (optional for Whisper only)
+
+## Quick Start
+
+### 1. Install Dependencies
+
+```bash
+# Using pip
+pip install modal httpx python-dotenv
+
+# Using uv (recommended)
+uv pip install modal httpx python-dotenv
+```
+
+### 2. Deploy to Modal
+
+```bash
+# Deploy the Whisper server
+modal deploy modal_whisper_server.py
+
+# You'll see output like:
+# ✓ Created deployment d-1234567890
+# View deployment: https://modal.com/apps/your-workspace/voicedform-whisper
+#
+# Web endpoint: https://your-workspace--voicedform-whisper-fastapi-app.modal.run
+```
+
+### 3. Configure Environment
+
+```bash
+# Copy the web endpoint URL from deployment output
+export WHISPER_API_URL="https://your-workspace--voicedform-whisper-fastapi-app.modal.run"
+
+# Or add to .env file
+echo "WHISPER_API_URL=https://your-workspace--voicedform-whisper-fastapi-app.modal.run" >> .env
+```
+
+### 4. Test the Deployment
+
+```bash
+# Test with a sample audio file
+python -c "
+from src.whisper_client import transcribe
+result = transcribe('test_audio.mp3')
+print(result.text)
+"
+```
+
+## Deployment Steps
+
+### Step 1: Deploy the Modal Server
+
+The Modal server hosts the Whisper model and provides API endpoints.
+
+```bash
+# Deploy to production
+modal deploy modal_whisper_server.py
+
+# Or run in development mode (with live reloading)
+modal serve modal_whisper_server.py
+```
+
+**Deployment options:**
+
+- `modal deploy`: Production deployment (persistent)
+- `modal serve`: Development deployment (stops when you exit)
+- `modal run`: Run once and exit (for testing)
+
+### Step 2: Get Your API URL
+
+After deployment, Modal will output your API URL:
+
+```
+Web endpoint: https://USERNAME--voicedform-whisper-fastapi-app.modal.run
+```
+
+### Step 3: Configure Your Application
+
+Add the API URL to your environment:
+
+**Option A: `.env` file (recommended)**
+
+```bash
+# .env
+WHISPER_API_URL=https://USERNAME--voicedform-whisper-fastapi-app.modal.run
+OPENAI_API_KEY=sk-...
+LANGSMITH_PROJECT=voicedform
+```
+
+**Option B: Environment variables**
+
+```bash
+export WHISPER_API_URL="https://USERNAME--voicedform-whisper-fastapi-app.modal.run"
+```
+
+### Step 4: Verify Deployment
+
+```bash
+# Check health endpoint
+curl https://USERNAME--voicedform-whisper-fastapi-app.modal.run/health
+
+# Expected response:
+# {"status":"healthy","service":"whisper-api"}
+```
+
+## Usage
+
+### Basic Transcription
+
+```python
+from src.whisper_client import WhisperClient
+
+# Initialize client
+client = WhisperClient()
+
+# Transcribe audio file
+result = client.transcribe("audio.mp3")
+
+if result.success:
+    print(f"Transcription: {result.text}")
+    print(f"Language: {result.language}")
+else:
+    print(f"Error: {result.error}")
+```
+
+### Advanced Options
+
+```python
+# Specify language (faster than auto-detect)
+result = client.transcribe(
+    "audio.mp3",
+    language="en",  # English
+    model_size="small",  # Use small model
+)
+
+# Translate to English
+result = client.transcribe(
+    "audio.mp3",
+    task="translate",  # Translate to English
+)
+
+# Guide transcription with context
+result = client.transcribe(
+    "audio.mp3",
+    initial_prompt="Form completion for accident report",
+    temperature=0.0,  # Deterministic output
+)
+```
+
+### Integration with VoicedForm Workflow
+
+```python
+from voicedform_graph_with_audio import process_voice_input, process_text_input
+
+# Process voice input
+result = process_voice_input("user_recording.mp3")
+print(result["form_complete"])
+
+# Process text input (no transcription)
+result = process_text_input("I need to report an accident")
+print(result["form_complete"])
+```
+
+### Async Usage
+
+```python
+import asyncio
+from src.whisper_client import WhisperClient
+
+async def transcribe_async():
+    client = WhisperClient()
+    result = await client.transcribe_async("audio.mp3")
+    return result.text
+
+# Run async
+text = asyncio.run(transcribe_async())
+```
+
+### HTTP API Usage
+
+You can also call the API directly with curl or any HTTP client:
+
+```bash
+# Transcribe audio file
+curl -X POST \
+  https://USERNAME--voicedform-whisper-fastapi-app.modal.run/transcribe \
+  -F "audio=@audio.mp3" \
+  -F "model_size=base" \
+  -F "language=en"
+
+# Response:
+# {
+#   "text": "This is the transcribed text",
+#   "language": "en",
+#   "segments": [...],
+#   "model_size": "base"
+# }
+```
+
+## Configuration
+
+### Whisper Model Sizes
+
+Choose the model size based on your accuracy vs. speed requirements:
+
+| Model  | Parameters | Speed    | Accuracy | Use Case                    |
+|--------|------------|----------|----------|-----------------------------|
+| tiny   | 39M        | Fastest  | Low      | Real-time, low accuracy OK  |
+| base   | 74M        | Fast     | Good     | **Recommended for most**    |
+| small  | 244M       | Medium   | Better   | Higher accuracy needed      |
+| medium | 769M       | Slow     | Great    | Critical accuracy           |
+| large  | 1550M      | Slowest  | Best     | Maximum accuracy            |
+
+**Recommendation**: Start with `base` for the best balance of speed and accuracy.
+
+### Environment Variables
+
+| Variable           | Description                              | Required | Default                    |
+|-------------------|------------------------------------------|----------|----------------------------|
+| `WHISPER_API_URL` | Modal Whisper API endpoint               | Yes      | None                       |
+| `OPENAI_API_KEY`  | OpenAI API key for LangGraph             | Yes*     | None                       |
+| `LANGSMITH_PROJECT` | LangSmith project for tracing          | No       | "voicedform"               |
+
+*Required only for full VoicedForm workflow, not for Whisper-only usage.
+
+### Modal Configuration
+
+Edit `modal_whisper_server.py` to customize:
+
+```python
+# GPU type (affects cost and speed)
+GPU_CONFIG = modal.gpu.A10G()  # Options: T4, A10G, A100
+
+# Container timeout (affects cost)
+container_idle_timeout=300,  # Keep warm for 5 minutes
+
+# Model cache volume
+model_cache = modal.Volume.from_name("whisper-model-cache", create_if_missing=True)
+```
+
+## Testing
+
+### 1. Test Modal Deployment Directly
+
+```bash
+# Test with CLI (requires audio file)
+modal run modal_whisper_server.py --audio-file test_audio.mp3 --model-size base
+```
+
+### 2. Test Python Client
+
+```python
+# test_whisper.py
+from src.whisper_client import WhisperClient
+
+def test_transcription():
+    client = WhisperClient()
+
+    # Test with sample audio
+    result = client.transcribe("test_audio.mp3")
+
+    assert result.success, f"Transcription failed: {result.error}"
+    assert len(result.text) > 0, "Empty transcription"
+    print(f"✓ Transcription: {result.text}")
+
+if __name__ == "__main__":
+    test_transcription()
+    print("✓ All tests passed!")
+```
+
+### 3. Test Full Workflow
+
+```bash
+# Run VoicedForm with audio input
+python voicedform_graph_with_audio.py test_audio.mp3
+```
+
+### 4. Test API Health
+
+```python
+from src.whisper_client import WhisperClient
+
+client = WhisperClient()
+if client.health_check():
+    print("✓ Whisper API is healthy")
+else:
+    print("✗ Whisper API is not accessible")
+```
+
+## Monitoring & Debugging
+
+### Modal Dashboard
+
+View logs and metrics at: https://modal.com/apps
+
+- **Logs**: Real-time function execution logs
+- **Metrics**: Request count, duration, errors
+- **Costs**: GPU usage and billing
+
+### Enable Debug Logging
+
+```python
+# In modal_whisper_server.py, add print statements
+print(f"Transcribing {len(audio_data)} bytes...")
+print(f"Result: {result['text']}")
+```
+
+### LangSmith Tracing (Optional)
+
+Enable LangSmith for end-to-end tracing:
+
+```bash
+# .env
+LANGCHAIN_TRACING_V2=true
+LANGCHAIN_API_KEY=your_langsmith_key
+LANGSMITH_PROJECT=voicedform
+```
+
+View traces at: https://smith.langchain.com
+
+### Common Debug Commands
+
+```bash
+# View Modal logs in real-time
+modal logs voicedform-whisper
+
+# View recent deployments
+modal app list
+
+# Get deployment details
+modal app describe voicedform-whisper
+```
+
+## Cost Optimization
+
+### 1. Choose the Right GPU
+
+```python
+# Cost-effective for most cases
+GPU_CONFIG = modal.gpu.T4()  # ~$0.60/hour
+
+# Recommended balance
+GPU_CONFIG = modal.gpu.A10G()  # ~$1.20/hour
+
+# High performance (expensive)
+GPU_CONFIG = modal.gpu.A100()  # ~$4.00/hour
+```
+
+### 2. Adjust Container Timeout
+
+```python
+# Shorter timeout = lower cost, but more cold starts
+container_idle_timeout=120,  # 2 minutes
+
+# Longer timeout = higher cost, but faster response
+container_idle_timeout=600,  # 10 minutes
+```
+
+### 3. Use Smaller Models When Possible
+
+```python
+# For testing/development
+model_size = "tiny"  # Fastest, cheapest
+
+# For production
+model_size = "base"  # Good balance
+```
+
+### 4. Batch Processing
+
+```python
+# Process multiple files in one request to amortize cold start
+for audio_file in audio_files:
+    result = client.transcribe(audio_file)
+```
+
+### Estimated Costs
+
+Based on Modal pricing (as of 2024):
+
+- **GPU time**: ~$0.60-$4.00/hour depending on GPU type
+- **Idle time**: Charged when container is kept warm
+- **Storage**: ~$0.10/GB/month for model cache
+
+**Example**:
+- 100 transcriptions/day
+- Average 30 seconds each
+- Base model on A10G GPU
+- Cost: ~$5-10/month
+
+## Troubleshooting
+
+### Issue: "No API URL configured"
+
+**Solution**: Set the `WHISPER_API_URL` environment variable:
+
+```bash
+export WHISPER_API_URL="https://your-url.modal.run"
+# Or add to .env file
+```
+
+### Issue: "Modal package not installed"
+
+**Solution**: Install Modal:
+
+```bash
+pip install modal
+```
+
+### Issue: "Authentication failed"
+
+**Solution**: Re-authenticate with Modal:
+
+```bash
+modal setup
+```
+
+### Issue: "GPU out of memory"
+
+**Solution**: Use a smaller model or upgrade GPU:
+
+```python
+# Option 1: Smaller model
+model_size = "small"  # Instead of "large"
+
+# Option 2: Bigger GPU
+GPU_CONFIG = modal.gpu.A100()
+```
+
+### Issue: "Transcription timeout"
+
+**Solution**: Increase timeout or split audio:
+
+```python
+# Increase timeout
+timeout=1200,  # 20 minutes
+
+# Or split long audio files
+# Use pydub or ffmpeg to split audio into chunks
+```
+
+### Issue: "Cold start is too slow"
+
+**Solution**: Keep containers warm longer:
+
+```python
+container_idle_timeout=600,  # 10 minutes instead of 5
+```
+
+### Issue: "Incorrect transcription"
+
+**Solutions**:
+
+1. **Use larger model**: `model_size="medium"`
+2. **Specify language**: `language="en"` instead of auto-detect
+3. **Add context**: `initial_prompt="Medical terminology, accident report"`
+4. **Check audio quality**: Ensure clear audio, minimal background noise
+
+### Getting Help
+
+- **Modal Docs**: https://modal.com/docs
+- **Whisper Docs**: https://github.com/openai/whisper
+- **Issues**: Open an issue on the VoicedForm repository
+
+## Next Steps
+
+- [ ] Deploy to production with `modal deploy`
+- [ ] Test with real audio samples
+- [ ] Integrate with your form completion workflow
+- [ ] Set up monitoring and alerts
+- [ ] Optimize model size and GPU type for your use case
+- [ ] Implement batch processing for multiple files
+
+## Additional Resources
+
+- [Modal Documentation](https://modal.com/docs)
+- [OpenAI Whisper Repository](https://github.com/openai/whisper)
+- [LangGraph Documentation](https://langchain-ai.github.io/langgraph/)
+- [VoicedForm GitHub](https://github.com/jojopeligroso/VoicedForm)
diff --git a/WHISPER_README.md b/WHISPER_README.md
new file mode 100644
index 0000000..b7327fb
--- /dev/null
+++ b/WHISPER_README.md
@@ -0,0 +1,427 @@
+# Whisper Integration for VoicedForm
+
+> Voice-driven form completion powered by OpenAI Whisper on Modal
+
+## Overview
+
+This integration adds speech-to-text capabilities to VoicedForm using OpenAI's Whisper model deployed on Modal's serverless GPU infrastructure. Users can now complete forms using voice input instead of typing.
+
+## Features
+
+- **High-Quality Transcription**: OpenAI Whisper provides state-of-the-art speech recognition
+- **Serverless Deployment**: Modal handles GPU provisioning and scaling automatically
+- **Multiple Model Sizes**: Choose from tiny to large models based on your accuracy needs
+- **REST API**: Easy integration via HTTP endpoints
+- **LangGraph Integration**: Seamlessly works with existing VoicedForm workflow
+- **Multi-language Support**: Automatic language detection and translation to English
+- **Cost-Effective**: Pay only for actual transcription time, not idle GPU time
+
+## Quick Start
+
+### 1. Install Dependencies
+
+```bash
+pip install modal httpx python-dotenv
+```
+
+### 2. Deploy Whisper Server
+
+```bash
+# Authenticate with Modal
+modal setup
+
+# Deploy the server
+modal deploy modal_whisper_server.py
+```
+
+### 3. Configure Environment
+
+Copy the API URL from deployment output and add to `.env`:
+
+```bash
+WHISPER_API_URL=https://your-workspace--voicedform-whisper-fastapi-app.modal.run
+OPENAI_API_KEY=sk-your-openai-key
+```
+
+### 4. Test Transcription
+
+```python
+from src.whisper_client import transcribe
+
+result = transcribe("audio.mp3")
+print(result.text)
+```
+
+## Architecture
+
+```
+┌──────────────┐
+│ Audio Input  │
+└──────┬───────┘
+       │
+       ▼
+┌─────────────────────┐
+│  WhisperClient      │  (src/whisper_client.py)
+│  - HTTP/gRPC        │
+└─────────┬───────────┘
+          │
+          ▼
+┌─────────────────────┐
+│  Modal Whisper API  │  (modal_whisper_server.py)
+│  - GPU-accelerated  │
+│  - FastAPI          │
+└─────────┬───────────┘
+          │
+          ▼
+┌─────────────────────┐
+│  OpenAI Whisper     │
+│  - Model inference  │
+└─────────────────────┘
+```
+
+## File Structure
+
+```
+VoicedForm/
+├── modal_whisper_server.py           # Modal server implementation
+├── src/
+│   └── whisper_client.py             # Python client for Whisper API
+├── voicedform_graph_with_audio.py    # Enhanced workflow with audio
+├── examples/
+│   └── whisper_usage_examples.py     # Usage examples
+├── tests/
+│   └── test_whisper_integration.py   # Integration tests
+├── WHISPER_DEPLOYMENT.md             # Detailed deployment guide
+└── WHISPER_README.md                 # This file
+```
+
+## Usage Examples
+
+### Basic Transcription
+
+```python
+from src.whisper_client import WhisperClient
+
+client = WhisperClient()
+result = client.transcribe("audio.mp3")
+
+if result.success:
+    print(f"Text: {result.text}")
+    print(f"Language: {result.language}")
+```
+
+### Specify Language (Faster)
+
+```python
+# Specifying language improves speed and accuracy
+result = client.transcribe("audio.mp3", language="en")
+```
+
+### Use Different Model Sizes
+
+```python
+# Tiny model - fastest, lowest accuracy
+client = WhisperClient(model_size="tiny")
+
+# Base model - good balance (recommended)
+client = WhisperClient(model_size="base")
+
+# Large model - best accuracy, slower
+client = WhisperClient(model_size="large")
+```
+
+### Translate to English
+
+```python
+# Automatically translate to English
+result = client.transcribe(
+    "spanish_audio.mp3",
+    task="translate"
+)
+```
+
+### Integration with VoicedForm
+
+```python
+from voicedform_graph_with_audio import process_voice_input
+
+# Process voice through complete workflow
+result = process_voice_input("accident_report_recording.mp3")
+
+print(f"Transcribed: {result['transcribed_text']}")
+print(f"Form Type: {result['form_type']}")
+print(f"Completed: {result['form_complete']}")
+```
+
+### Async Transcription
+
+```python
+import asyncio
+
+async def transcribe_multiple():
+    client = WhisperClient()
+
+    results = await asyncio.gather(
+        client.transcribe_async("file1.mp3"),
+        client.transcribe_async("file2.mp3"),
+        client.transcribe_async("file3.mp3"),
+    )
+
+    for result in results:
+        print(result.text)
+
+asyncio.run(transcribe_multiple())
+```
+
+## Configuration
+
+### Environment Variables
+
+| Variable | Description | Required |
+|----------|-------------|----------|
+| `WHISPER_API_URL` | Modal Whisper API endpoint | Yes |
+| `OPENAI_API_KEY` | OpenAI API key for LangGraph | Yes* |
+
+*Required for full VoicedForm workflow, not for Whisper-only usage
+
+### Model Sizes
+
+| Model | Size | Speed | Accuracy | Best For |
+|-------|------|-------|----------|----------|
+| tiny | 39M | Fastest | Low | Real-time, low accuracy OK |
+| base | 74M | Fast | Good | **Recommended default** |
+| small | 244M | Medium | Better | Higher accuracy needed |
+| medium | 769M | Slow | Great | Critical accuracy |
+| large | 1550M | Slowest | Best | Maximum quality |
+
+### GPU Options
+
+Edit `modal_whisper_server.py` to change GPU type:
+
+```python
+# Cost-effective
+GPU_CONFIG = modal.gpu.T4()  # ~$0.60/hour
+
+# Recommended
+GPU_CONFIG = modal.gpu.A10G()  # ~$1.20/hour
+
+# High performance
+GPU_CONFIG = modal.gpu.A100()  # ~$4.00/hour
+```
+
+## API Reference
+
+### WhisperClient
+
+```python
+class WhisperClient:
+    def __init__(
+        self,
+        api_url: Optional[str] = None,
+        model_size: str = "base",
+        use_direct_modal: bool = False,
+    )
+
+    def transcribe(
+        self,
+        audio: Union[str, Path, bytes],
+        language: Optional[str] = None,
+        task: str = "transcribe",
+        temperature: float = 0.0,
+        initial_prompt: Optional[str] = None,
+        model_size: Optional[str] = None,
+    ) -> WhisperTranscriptionResult
+
+    async def transcribe_async(...) -> WhisperTranscriptionResult
+
+    def health_check(self) -> bool
+```
+
+### WhisperTranscriptionResult
+
+```python
+class WhisperTranscriptionResult:
+    text: str                    # Transcribed text
+    language: str                # Detected language
+    segments: List[dict]         # Segments with timing
+    model_size: str              # Model used
+    error: Optional[str]         # Error message if failed
+    success: bool                # True if successful
+```
+
+### REST API Endpoints
+
+#### `POST /transcribe`
+
+Transcribe audio file to text.
+
+**Parameters:**
+- `audio` (file): Audio file to transcribe
+- `model_size` (string): Model size (tiny/base/small/medium/large)
+- `language` (string, optional): ISO language code
+- `task` (string): 'transcribe' or 'translate'
+- `temperature` (float): Sampling temperature (0.0-1.0)
+- `initial_prompt` (string, optional): Context for transcription
+
+**Response:**
+```json
+{
+  "text": "Transcribed text here",
+  "language": "en",
+  "segments": [
+    {"text": "Segment 1", "start": 0.0, "end": 2.5}
+  ],
+  "model_size": "base"
+}
+```
+
+#### `GET /health`
+
+Health check endpoint.
+
+**Response:**
+```json
+{
+  "status": "healthy",
+  "service": "whisper-api"
+}
+```
+
+## Testing
+
+### Run Integration Tests
+
+```bash
+# Install pytest
+pip install pytest pytest-asyncio
+
+# Run tests
+pytest tests/test_whisper_integration.py -v
+```
+
+### Run Examples
+
+```bash
+# Run all usage examples
+python examples/whisper_usage_examples.py
+
+# Test with your own audio file
+python voicedform_graph_with_audio.py your_audio.mp3
+```
+
+### Test Deployment
+
+```bash
+# Test Modal deployment directly
+modal run modal_whisper_server.py --audio-file test.mp3
+```
+
+## Deployment
+
+See [WHISPER_DEPLOYMENT.md](WHISPER_DEPLOYMENT.md) for comprehensive deployment guide covering:
+
+- Prerequisites and setup
+- Step-by-step deployment instructions
+- Configuration options
+- Monitoring and debugging
+- Cost optimization strategies
+- Troubleshooting common issues
+
+## Performance
+
+### Typical Latency
+
+| Model | Cold Start | Warm Start | Transcription (1 min audio) |
+|-------|-----------|------------|---------------------------|
+| tiny | ~3s | <100ms | ~2s |
+| base | ~4s | <100ms | ~4s |
+| small | ~6s | <100ms | ~8s |
+| medium | ~10s | <100ms | ~15s |
+| large | ~15s | <100ms | ~30s |
+
+### Optimization Tips
+
+1. **Keep containers warm**: Increase `container_idle_timeout`
+2. **Specify language**: Faster than auto-detection
+3. **Use base model**: Best balance for most use cases
+4. **Batch processing**: Process multiple files in sequence
+
+## Cost Estimation
+
+Based on Modal pricing (2024):
+
+**Example Usage:**
+- 100 transcriptions per day
+- Average 1 minute audio per file
+- Base model on A10G GPU
+- 5 minute container idle timeout
+
+**Monthly Cost:** ~$5-10
+
+**Cost Breakdown:**
+- GPU time: ~$1.20/hour × (100 × 4s / 3600) = ~$0.13/day
+- Idle time: Depends on traffic pattern
+- Storage: <$0.10/month for model cache
+
+## Troubleshooting
+
+### Common Issues
+
+**"No API URL configured"**
+```bash
+export WHISPER_API_URL="your-modal-url"
+```
+
+**"Modal package not installed"**
+```bash
+pip install modal
+```
+
+**"Authentication failed"**
+```bash
+modal setup
+```
+
+**Slow transcription**
+- Use smaller model (tiny or base)
+- Specify language instead of auto-detect
+- Split long audio files
+
+**Low accuracy**
+- Use larger model (medium or large)
+- Add context via `initial_prompt`
+- Ensure audio quality is good
+
+See [WHISPER_DEPLOYMENT.md](WHISPER_DEPLOYMENT.md) for more troubleshooting help.
+
+## Support
+
+- **Documentation**: See `WHISPER_DEPLOYMENT.md`
+- **Examples**: See `examples/whisper_usage_examples.py`
+- **Tests**: See `tests/test_whisper_integration.py`
+- **Modal Docs**: https://modal.com/docs
+- **Whisper Docs**: https://github.com/openai/whisper
+
+## License
+
+MIT License - see LICENSE file for details
+
+## Contributing
+
+Contributions welcome! Please:
+
+1. Test your changes with `pytest`
+2. Follow existing code style
+3. Update documentation as needed
+4. Add examples for new features
+
+## Changelog
+
+### v1.0.0 (2024)
+
+- Initial Whisper integration
+- Modal serverless deployment
+- Python client library
+- LangGraph workflow integration
+- Comprehensive documentation
+- Example code and tests
diff --git a/examples/whisper_usage_examples.py b/examples/whisper_usage_examples.py
new file mode 100644
index 0000000..662ad64
--- /dev/null
+++ b/examples/whisper_usage_examples.py
@@ -0,0 +1,343 @@
+"""
+Whisper Usage Examples for VoicedForm
+
+This file demonstrates various ways to use the Whisper integration
+in VoicedForm for speech-to-text transcription.
+"""
+
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Import WhisperClient
+from src.whisper_client import WhisperClient, transcribe
+
+
+def example_1_basic_transcription():
+    """
+    Example 1: Basic transcription with default settings
+
+    This is the simplest way to transcribe an audio file.
+    """
+    print("\n" + "=" * 80)
+    print("Example 1: Basic Transcription")
+    print("=" * 80)
+
+    # Initialize client
+    client = WhisperClient()
+
+    # Transcribe audio file (replace with your actual file)
+    audio_file = "sample_audio.mp3"
+
+    if not Path(audio_file).exists():
+        print(f"⚠️  Audio file not found: {audio_file}")
+        print("   Please provide a real audio file to test.")
+        return
+
+    result = client.transcribe(audio_file)
+
+    if result.success:
+        print(f"✓ Success!")
+        print(f"  Text: {result.text}")
+        print(f"  Language: {result.language}")
+        print(f"  Model: {result.model_size}")
+    else:
+        print(f"✗ Error: {result.error}")
+
+
+def example_2_specify_language():
+    """
+    Example 2: Specify language for faster transcription
+
+    If you know the language, specifying it speeds up transcription
+    and improves accuracy.
+    """
+    print("\n" + "=" * 80)
+    print("Example 2: Transcription with Language Specified")
+    print("=" * 80)
+
+    client = WhisperClient()
+
+    # Transcribe with language specified (faster than auto-detect)
+    result = client.transcribe(
+        "sample_audio.mp3",
+        language="en",  # English
+    )
+
+    if result.success:
+        print(f"✓ Transcribed as English:")
+        print(f"  {result.text}")
+
+
+def example_3_different_model_sizes():
+    """
+    Example 3: Using different model sizes
+
+    Demonstrates how to use different Whisper models based on your
+    accuracy vs. speed requirements.
+    """
+    print("\n" + "=" * 80)
+    print("Example 3: Different Model Sizes")
+    print("=" * 80)
+
+    audio_file = "sample_audio.mp3"
+
+    if not Path(audio_file).exists():
+        print(f"⚠️  Audio file not found, using placeholder")
+        return
+
+    models = ["tiny", "base", "small"]
+
+    for model_size in models:
+        print(f"\nTesting with {model_size} model...")
+        client = WhisperClient(model_size=model_size)
+        result = client.transcribe(audio_file)
+
+        if result.success:
+            print(f"  ✓ {model_size}: {result.text[:50]}...")
+
+
+def example_4_translation():
+    """
+    Example 4: Translate to English
+
+    Whisper can automatically translate non-English audio to English.
+    """
+    print("\n" + "=" * 80)
+    print("Example 4: Translation to English")
+    print("=" * 80)
+
+    client = WhisperClient()
+
+    # Translate Spanish audio to English
+    result = client.transcribe(
+        "spanish_audio.mp3",
+        task="translate",  # Translate to English
+    )
+
+    if result.success:
+        print(f"✓ Translated to English:")
+        print(f"  {result.text}")
+    else:
+        print(f"ℹ️  Skipping - no Spanish audio file available")
+
+
+def example_5_with_context():
+    """
+    Example 5: Providing context for better accuracy
+
+    The initial_prompt helps guide Whisper to understand context,
+    proper nouns, and domain-specific terminology.
+    """
+    print("\n" + "=" * 80)
+    print("Example 5: Transcription with Context")
+    print("=" * 80)
+
+    client = WhisperClient()
+
+    # Provide context about what the audio is about
+    result = client.transcribe(
+        "sample_audio.mp3",
+        initial_prompt="This is an accident report form. "
+                      "The speaker is describing a car accident on Main Street.",
+        temperature=0.0,  # Deterministic output
+    )
+
+    if result.success:
+        print(f"✓ Transcription with context:")
+        print(f"  {result.text}")
+
+
+def example_6_with_segments():
+    """
+    Example 6: Working with transcription segments
+
+    Access individual segments with timing information for
+    more detailed analysis.
+    """
+    print("\n" + "=" * 80)
+    print("Example 6: Transcription Segments with Timing")
+    print("=" * 80)
+
+    client = WhisperClient()
+    result = client.transcribe("sample_audio.mp3")
+
+    if result.success:
+        print(f"✓ Full text: {result.text}\n")
+        print(f"  Segments ({len(result.segments)}):")
+
+        for i, segment in enumerate(result.segments[:5], 1):  # Show first 5
+            start = segment['start']
+            end = segment['end']
+            text = segment['text']
+            print(f"  [{start:.1f}s - {end:.1f}s] {text}")
+
+
+def example_7_convenience_function():
+    """
+    Example 7: Using the convenience function
+
+    For quick, simple transcriptions without needing to create a client.
+    """
+    print("\n" + "=" * 80)
+    print("Example 7: Convenience Function")
+    print("=" * 80)
+
+    # Quick one-line transcription
+    result = transcribe(
+        "sample_audio.mp3",
+        model_size="base",
+        language="en",
+    )
+
+    if result.success:
+        print(f"✓ Quick transcription: {result.text}")
+
+
+def example_8_async_transcription():
+    """
+    Example 8: Async transcription for concurrent operations
+
+    Use async/await for transcribing multiple files concurrently.
+    """
+    print("\n" + "=" * 80)
+    print("Example 8: Async Transcription")
+    print("=" * 80)
+
+    import asyncio
+
+    async def transcribe_multiple_files():
+        client = WhisperClient()
+
+        audio_files = ["file1.mp3", "file2.mp3", "file3.mp3"]
+
+        # Create tasks for concurrent transcription
+        tasks = [
+            client.transcribe_async(audio_file)
+            for audio_file in audio_files
+            if Path(audio_file).exists()
+        ]
+
+        # Wait for all transcriptions to complete
+        results = await asyncio.gather(*tasks)
+
+        for i, result in enumerate(results, 1):
+            if result.success:
+                print(f"  ✓ File {i}: {result.text[:50]}...")
+
+    # Run async function
+    if any(Path(f).exists() for f in ["file1.mp3", "file2.mp3", "file3.mp3"]):
+        asyncio.run(transcribe_multiple_files())
+    else:
+        print("  ℹ️  No audio files found for async example")
+
+
+def example_9_error_handling():
+    """
+    Example 9: Proper error handling
+
+    Always check for errors and handle them appropriately.
+    """
+    print("\n" + "=" * 80)
+    print("Example 9: Error Handling")
+    print("=" * 80)
+
+    client = WhisperClient()
+
+    # Try to transcribe non-existent file
+    result = client.transcribe("nonexistent.mp3")
+
+    if result.success:
+        print(f"✓ Text: {result.text}")
+    else:
+        print(f"✗ Expected error occurred: {result.error}")
+
+    # Check API health before transcribing
+    if client.health_check():
+        print("✓ API is healthy, proceeding with transcription...")
+    else:
+        print("✗ API is not accessible. Please check WHISPER_API_URL.")
+
+
+def example_10_integration_with_voicedform():
+    """
+    Example 10: Integration with VoicedForm workflow
+
+    Show how to use Whisper transcription in the full VoicedForm graph.
+    """
+    print("\n" + "=" * 80)
+    print("Example 10: VoicedForm Integration")
+    print("=" * 80)
+
+    try:
+        from voicedform_graph_with_audio import process_voice_input, process_text_input
+
+        # Process voice input through full workflow
+        audio_file = "accident_report.mp3"
+
+        if Path(audio_file).exists():
+            print(f"Processing voice input: {audio_file}")
+            result = process_voice_input(audio_file)
+
+            print(f"\n✓ Workflow complete!")
+            print(f"  Transcribed: {result.get('transcribed_text', 'N/A')[:50]}...")
+            print(f"  Form Type: {result.get('form_type')}")
+            print(f"  Valid: {result.get('valid')}")
+        else:
+            # Fallback to text input
+            print("No audio file, using text input instead")
+            result = process_text_input(
+                "I need to report an accident that happened on Main Street today"
+            )
+            print(f"\n✓ Text workflow complete!")
+            print(f"  Form Type: {result.get('form_type')}")
+            print(f"  Valid: {result.get('valid')}")
+
+    except ImportError:
+        print("  ℹ️  VoicedForm graph module not available")
+
+
+def main():
+    """Run all examples"""
+
+    print("\n" + "╔" + "=" * 78 + "╗")
+    print("║" + " " * 20 + "WHISPER USAGE EXAMPLES" + " " * 35 + "║")
+    print("╚" + "=" * 78 + "╝")
+
+    # Check environment
+    api_url = os.getenv("WHISPER_API_URL")
+    if not api_url:
+        print("\n⚠️  WARNING: WHISPER_API_URL not set!")
+        print("   Set it in .env or export WHISPER_API_URL=your_modal_url")
+        print("   Some examples will fail without it.\n")
+
+    # Run examples
+    examples = [
+        example_1_basic_transcription,
+        example_2_specify_language,
+        example_3_different_model_sizes,
+        example_4_translation,
+        example_5_with_context,
+        example_6_with_segments,
+        example_7_convenience_function,
+        example_8_async_transcription,
+        example_9_error_handling,
+        example_10_integration_with_voicedform,
+    ]
+
+    for example_func in examples:
+        try:
+            example_func()
+        except Exception as e:
+            print(f"\n✗ Example failed: {e}")
+
+    print("\n" + "=" * 80)
+    print("Examples complete!")
+    print("=" * 80 + "\n")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/modal_whisper_server.py b/modal_whisper_server.py
new file mode 100644
index 0000000..09a0ce2
--- /dev/null
+++ b/modal_whisper_server.py
@@ -0,0 +1,328 @@
+"""
+Modal Whisper Server for VoicedForm
+
+This module provides a serverless Whisper speech-to-text service using Modal.
+It supports multiple Whisper model sizes and provides a REST API for transcription.
+
+Key Features:
+- Serverless deployment on Modal infrastructure
+- Multiple Whisper model sizes (tiny, base, small, medium, large)
+- Automatic model caching for fast cold starts
+- RESTful API with FastAPI
+- Support for various audio formats
+- Language detection and multilingual support
+"""
+
+import io
+import os
+from pathlib import Path
+from typing import Optional
+
+import modal
+
+# Modal configuration
+APP_NAME = "voicedform-whisper"
+GPU_CONFIG = modal.gpu.A10G()  # Good balance of cost and performance for Whisper
+
+# Create Modal app
+app = modal.App(APP_NAME)
+
+# Define the Modal image with all required dependencies
+whisper_image = (
+    modal.Image.debian_slim(python_version="3.11")
+    .apt_install("ffmpeg")  # Required for audio processing
+    .pip_install(
+        "openai-whisper==20231117",
+        "torch==2.1.2",
+        "torchaudio==2.1.2",
+        "fastapi[standard]==0.115.4",
+        "python-multipart==0.0.12",
+    )
+)
+
+# Volume for model caching
+model_cache = modal.Volume.from_name("whisper-model-cache", create_if_missing=True)
+MODEL_CACHE_DIR = "/cache/whisper"
+
+
+@app.cls(
+    image=whisper_image,
+    gpu=GPU_CONFIG,
+    volumes={MODEL_CACHE_DIR: model_cache},
+    container_idle_timeout=300,  # Keep warm for 5 minutes
+    timeout=600,  # 10 minute max execution time
+)
+class WhisperModel:
+    """
+    Modal class for running Whisper speech-to-text inference.
+
+    The model is loaded on container start and cached to the volume for fast
+    subsequent cold starts.
+    """
+
+    model_size: str = "base"  # Default model size
+
+    @modal.build()
+    def download_model(self):
+        """Download and cache the Whisper model during image build."""
+        import whisper
+
+        # Download model to cache directory
+        whisper.load_model(
+            self.model_size,
+            download_root=MODEL_CACHE_DIR
+        )
+        print(f"✓ Downloaded Whisper {self.model_size} model to cache")
+
+    @modal.enter()
+    def load_model(self):
+        """Load the Whisper model when container starts."""
+        import whisper
+        import torch
+
+        print(f"Loading Whisper {self.model_size} model...")
+
+        # Set cache directory
+        os.environ["WHISPER_CACHE_DIR"] = MODEL_CACHE_DIR
+
+        # Load model from cache
+        self.model = whisper.load_model(
+            self.model_size,
+            download_root=MODEL_CACHE_DIR
+        )
+
+        # Check if GPU is available
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(f"✓ Loaded Whisper {self.model_size} model on {self.device}")
+
+    @modal.method()
+    def transcribe(
+        self,
+        audio_data: bytes,
+        language: Optional[str] = None,
+        task: str = "transcribe",
+        temperature: float = 0.0,
+        initial_prompt: Optional[str] = None,
+    ) -> dict:
+        """
+        Transcribe audio data to text using Whisper.
+
+        Args:
+            audio_data: Raw audio file bytes (any format supported by ffmpeg)
+            language: ISO language code (e.g., 'en', 'es'). None for auto-detect.
+            task: Either 'transcribe' or 'translate' (to English)
+            temperature: Sampling temperature (0.0 = deterministic)
+            initial_prompt: Optional text to guide the model
+
+        Returns:
+            dict: Transcription result with text, segments, and metadata
+        """
+        import tempfile
+        import whisper
+
+        try:
+            # Write audio bytes to temporary file
+            with tempfile.NamedTemporaryFile(suffix=".audio", delete=False) as tmp_file:
+                tmp_file.write(audio_data)
+                tmp_path = tmp_file.name
+
+            # Prepare transcription options
+            options = {
+                "task": task,
+                "temperature": temperature,
+            }
+
+            if language:
+                options["language"] = language
+
+            if initial_prompt:
+                options["initial_prompt"] = initial_prompt
+
+            # Transcribe
+            result = self.model.transcribe(tmp_path, **options)
+
+            # Clean up temp file
+            Path(tmp_path).unlink(missing_ok=True)
+
+            # Return formatted result
+            return {
+                "text": result["text"].strip(),
+                "language": result.get("language", "unknown"),
+                "segments": [
+                    {
+                        "text": seg["text"].strip(),
+                        "start": seg["start"],
+                        "end": seg["end"],
+                    }
+                    for seg in result.get("segments", [])
+                ],
+                "model_size": self.model_size,
+            }
+
+        except Exception as e:
+            return {
+                "error": str(e),
+                "text": "",
+                "language": "unknown",
+                "segments": [],
+            }
+
+
+# FastAPI web endpoint
+@app.function(
+    image=whisper_image,
+)
+@modal.asgi_app()
+def fastapi_app():
+    """
+    FastAPI application for REST API access to Whisper transcription.
+
+    Endpoints:
+        POST /transcribe - Transcribe audio file
+        GET /health - Health check
+        GET / - API documentation
+    """
+    from fastapi import FastAPI, File, UploadFile, Form, HTTPException
+    from fastapi.responses import JSONResponse
+
+    web_app = FastAPI(
+        title="VoicedForm Whisper API",
+        description="Speech-to-text transcription service using OpenAI Whisper",
+        version="1.0.0",
+    )
+
+    @web_app.get("/")
+    async def root():
+        """API documentation and information."""
+        return {
+            "service": "VoicedForm Whisper API",
+            "version": "1.0.0",
+            "endpoints": {
+                "POST /transcribe": "Transcribe audio file to text",
+                "GET /health": "Health check endpoint",
+            },
+            "supported_formats": [
+                "mp3", "wav", "m4a", "ogg", "flac", "webm", "mp4"
+            ],
+            "models": ["tiny", "base", "small", "medium", "large"],
+        }
+
+    @web_app.get("/health")
+    async def health():
+        """Health check endpoint."""
+        return {"status": "healthy", "service": "whisper-api"}
+
+    @web_app.post("/transcribe")
+    async def transcribe_audio(
+        audio: UploadFile = File(..., description="Audio file to transcribe"),
+        model_size: str = Form("base", description="Whisper model size"),
+        language: Optional[str] = Form(None, description="ISO language code (e.g., 'en')"),
+        task: str = Form("transcribe", description="'transcribe' or 'translate'"),
+        temperature: float = Form(0.0, description="Sampling temperature"),
+        initial_prompt: Optional[str] = Form(None, description="Optional text to guide transcription"),
+    ):
+        """
+        Transcribe an audio file to text.
+
+        Upload an audio file and receive the transcribed text along with
+        timing information for each segment.
+        """
+        # Validate model size
+        valid_models = ["tiny", "base", "small", "medium", "large"]
+        if model_size not in valid_models:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Invalid model_size. Must be one of: {valid_models}"
+            )
+
+        # Validate task
+        if task not in ["transcribe", "translate"]:
+            raise HTTPException(
+                status_code=400,
+                detail="Task must be either 'transcribe' or 'translate'"
+            )
+
+        try:
+            # Read audio file
+            audio_data = await audio.read()
+
+            if len(audio_data) == 0:
+                raise HTTPException(
+                    status_code=400,
+                    detail="Empty audio file"
+                )
+
+            # Create model instance with specified size
+            model = WhisperModel(model_size=model_size)
+
+            # Transcribe
+            result = model.transcribe.remote(
+                audio_data=audio_data,
+                language=language,
+                task=task,
+                temperature=temperature,
+                initial_prompt=initial_prompt,
+            )
+
+            # Check for errors
+            if "error" in result and result["error"]:
+                raise HTTPException(
+                    status_code=500,
+                    detail=f"Transcription error: {result['error']}"
+                )
+
+            return JSONResponse(content=result)
+
+        except HTTPException:
+            raise
+        except Exception as e:
+            raise HTTPException(
+                status_code=500,
+                detail=f"Internal server error: {str(e)}"
+            )
+
+
+# CLI for local testing and deployment
+@app.local_entrypoint()
+def main(
+    audio_file: str = "test.mp3",
+    model_size: str = "base",
+    language: Optional[str] = None,
+):
+    """
+    Local CLI for testing Whisper transcription.
+
+    Usage:
+        modal run modal_whisper_server.py --audio-file path/to/audio.mp3
+    """
+    from pathlib import Path
+
+    audio_path = Path(audio_file)
+
+    if not audio_path.exists():
+        print(f"Error: Audio file not found: {audio_file}")
+        return
+
+    print(f"Transcribing {audio_file} with {model_size} model...")
+
+    # Read audio file
+    audio_data = audio_path.read_bytes()
+
+    # Create model and transcribe
+    model = WhisperModel(model_size=model_size)
+    result = model.transcribe.remote(
+        audio_data=audio_data,
+        language=language,
+    )
+
+    # Print results
+    print("\n" + "=" * 80)
+    print("TRANSCRIPTION RESULT")
+    print("=" * 80)
+    print(f"\nText: {result['text']}")
+    print(f"Language: {result['language']}")
+    print(f"Model: {result['model_size']}")
+    print(f"\nSegments ({len(result['segments'])}):")
+    for i, seg in enumerate(result['segments'], 1):
+        print(f"  [{seg['start']:.2f}s - {seg['end']:.2f}s] {seg['text']}")
+    print("=" * 80)
diff --git a/pyproject.toml b/pyproject.toml
index 4db0e6c..bb8a8dc 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -9,8 +9,11 @@ readme = "README.md"
 license = { text = "MIT" }
 requires-python = ">=3.10"
 dependencies = [
-    "langgraph>=1.0.0",
+    "langgraph>=0.2.6",
+    "langchain-openai>=0.2.0",
     "python-dotenv>=1.0.1",
+    "httpx>=0.27.0",
+    "modal>=0.64.0",
 ]
 
 
diff --git a/src/whisper_client.py b/src/whisper_client.py
new file mode 100644
index 0000000..5f5e026
--- /dev/null
+++ b/src/whisper_client.py
@@ -0,0 +1,368 @@
+"""
+Whisper Client for VoicedForm
+
+This module provides a client interface to the Modal Whisper server for
+transcribing audio in the VoicedForm application.
+
+The client supports two modes:
+1. Direct Modal function calls (when running in Modal environment)
+2. HTTP API calls (when running locally or from other environments)
+"""
+
+import os
+from pathlib import Path
+from typing import Optional, Union, Literal
+import warnings
+
+
+class WhisperTranscriptionResult:
+    """
+    Represents the result of a Whisper transcription.
+
+    Attributes:
+        text: The full transcribed text
+        language: Detected or specified language code
+        segments: List of transcription segments with timing
+        model_size: The Whisper model size used
+        error: Error message if transcription failed
+    """
+
+    def __init__(self, data: dict):
+        self.text = data.get("text", "")
+        self.language = data.get("language", "unknown")
+        self.segments = data.get("segments", [])
+        self.model_size = data.get("model_size", "unknown")
+        self.error = data.get("error")
+
+    @property
+    def success(self) -> bool:
+        """Returns True if transcription was successful."""
+        return bool(self.text and not self.error)
+
+    def __str__(self) -> str:
+        if self.error:
+            return f"WhisperTranscriptionResult(error={self.error})"
+        return f"WhisperTranscriptionResult(text='{self.text[:50]}...', language={self.language})"
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+
+class WhisperClient:
+    """
+    Client for interacting with the Modal Whisper server.
+
+    This client provides a high-level interface for transcribing audio files
+    using the Modal-hosted Whisper service. It automatically handles both
+    direct Modal function calls and HTTP API requests.
+
+    Example:
+        >>> client = WhisperClient(api_url="https://your-modal-app.modal.run")
+        >>> result = client.transcribe("audio.mp3")
+        >>> print(result.text)
+    """
+
+    def __init__(
+        self,
+        api_url: Optional[str] = None,
+        model_size: Literal["tiny", "base", "small", "medium", "large"] = "base",
+        use_direct_modal: bool = False,
+    ):
+        """
+        Initialize the Whisper client.
+
+        Args:
+            api_url: URL of the Modal Whisper API (e.g., "https://your-app.modal.run")
+                     Can also be set via WHISPER_API_URL environment variable
+            model_size: Default Whisper model size to use
+            use_direct_modal: If True, use direct Modal function calls instead of HTTP
+        """
+        self.api_url = api_url or os.getenv("WHISPER_API_URL")
+        self.model_size = model_size
+        self.use_direct_modal = use_direct_modal
+
+        if not self.api_url and not use_direct_modal:
+            warnings.warn(
+                "No API URL provided and use_direct_modal=False. "
+                "Set WHISPER_API_URL environment variable or pass api_url parameter.",
+                UserWarning
+            )
+
+    def transcribe(
+        self,
+        audio: Union[str, Path, bytes],
+        language: Optional[str] = None,
+        task: Literal["transcribe", "translate"] = "transcribe",
+        temperature: float = 0.0,
+        initial_prompt: Optional[str] = None,
+        model_size: Optional[str] = None,
+    ) -> WhisperTranscriptionResult:
+        """
+        Transcribe audio to text using Whisper.
+
+        Args:
+            audio: Path to audio file or raw audio bytes
+            language: ISO language code (e.g., 'en', 'es'). None for auto-detect.
+            task: Either 'transcribe' or 'translate' (translate to English)
+            temperature: Sampling temperature (0.0 = deterministic, more consistent)
+            initial_prompt: Optional text to guide the transcription (e.g., proper nouns)
+            model_size: Override default model size for this request
+
+        Returns:
+            WhisperTranscriptionResult with transcription text and metadata
+
+        Example:
+            >>> client = WhisperClient()
+            >>> result = client.transcribe("audio.mp3", language="en")
+            >>> if result.success:
+            ...     print(f"Transcription: {result.text}")
+        """
+        # Read audio data
+        if isinstance(audio, (str, Path)):
+            audio_path = Path(audio)
+            if not audio_path.exists():
+                return WhisperTranscriptionResult({
+                    "error": f"Audio file not found: {audio}",
+                    "text": "",
+                })
+            audio_data = audio_path.read_bytes()
+            filename = audio_path.name
+        else:
+            audio_data = audio
+            filename = "audio.unknown"
+
+        # Use specified model size or default
+        model = model_size or self.model_size
+
+        if self.use_direct_modal:
+            return self._transcribe_direct(
+                audio_data=audio_data,
+                language=language,
+                task=task,
+                temperature=temperature,
+                initial_prompt=initial_prompt,
+                model_size=model,
+            )
+        else:
+            return self._transcribe_http(
+                audio_data=audio_data,
+                filename=filename,
+                language=language,
+                task=task,
+                temperature=temperature,
+                initial_prompt=initial_prompt,
+                model_size=model,
+            )
+
+    def _transcribe_direct(
+        self,
+        audio_data: bytes,
+        language: Optional[str],
+        task: str,
+        temperature: float,
+        initial_prompt: Optional[str],
+        model_size: str,
+    ) -> WhisperTranscriptionResult:
+        """Use direct Modal function calls (requires modal package)."""
+        try:
+            from modal_whisper_server import WhisperModel
+
+            model = WhisperModel(model_size=model_size)
+            result = model.transcribe.remote(
+                audio_data=audio_data,
+                language=language,
+                task=task,
+                temperature=temperature,
+                initial_prompt=initial_prompt,
+            )
+            return WhisperTranscriptionResult(result)
+
+        except ImportError:
+            return WhisperTranscriptionResult({
+                "error": "Modal package not installed. Install with: pip install modal",
+                "text": "",
+            })
+        except Exception as e:
+            return WhisperTranscriptionResult({
+                "error": f"Direct Modal transcription failed: {str(e)}",
+                "text": "",
+            })
+
+    def _transcribe_http(
+        self,
+        audio_data: bytes,
+        filename: str,
+        language: Optional[str],
+        task: str,
+        temperature: float,
+        initial_prompt: Optional[str],
+        model_size: str,
+    ) -> WhisperTranscriptionResult:
+        """Use HTTP API calls to Modal Whisper server."""
+        if not self.api_url:
+            return WhisperTranscriptionResult({
+                "error": "No API URL configured. Set WHISPER_API_URL or pass api_url to constructor.",
+                "text": "",
+            })
+
+        try:
+            import httpx
+
+            url = f"{self.api_url.rstrip('/')}/transcribe"
+
+            # Prepare form data
+            files = {"audio": (filename, audio_data)}
+            data = {
+                "model_size": model_size,
+                "task": task,
+                "temperature": str(temperature),
+            }
+
+            if language:
+                data["language"] = language
+
+            if initial_prompt:
+                data["initial_prompt"] = initial_prompt
+
+            # Make request with timeout
+            with httpx.Client(timeout=300.0) as client:  # 5 minute timeout
+                response = client.post(url, files=files, data=data)
+                response.raise_for_status()
+                result = response.json()
+
+            return WhisperTranscriptionResult(result)
+
+        except ImportError:
+            return WhisperTranscriptionResult({
+                "error": "httpx package not installed. Install with: pip install httpx",
+                "text": "",
+            })
+        except Exception as e:
+            return WhisperTranscriptionResult({
+                "error": f"HTTP transcription failed: {str(e)}",
+                "text": "",
+            })
+
+    async def transcribe_async(
+        self,
+        audio: Union[str, Path, bytes],
+        language: Optional[str] = None,
+        task: Literal["transcribe", "translate"] = "transcribe",
+        temperature: float = 0.0,
+        initial_prompt: Optional[str] = None,
+        model_size: Optional[str] = None,
+    ) -> WhisperTranscriptionResult:
+        """
+        Async version of transcribe() for use in async contexts.
+
+        Args: Same as transcribe()
+
+        Returns:
+            WhisperTranscriptionResult with transcription text and metadata
+        """
+        # Read audio data
+        if isinstance(audio, (str, Path)):
+            audio_path = Path(audio)
+            if not audio_path.exists():
+                return WhisperTranscriptionResult({
+                    "error": f"Audio file not found: {audio}",
+                    "text": "",
+                })
+            audio_data = audio_path.read_bytes()
+            filename = audio_path.name
+        else:
+            audio_data = audio
+            filename = "audio.unknown"
+
+        model = model_size or self.model_size
+
+        if not self.api_url:
+            return WhisperTranscriptionResult({
+                "error": "No API URL configured. Set WHISPER_API_URL or pass api_url to constructor.",
+                "text": "",
+            })
+
+        try:
+            import httpx
+
+            url = f"{self.api_url.rstrip('/')}/transcribe"
+
+            files = {"audio": (filename, audio_data)}
+            data = {
+                "model_size": model,
+                "task": task,
+                "temperature": str(temperature),
+            }
+
+            if language:
+                data["language"] = language
+
+            if initial_prompt:
+                data["initial_prompt"] = initial_prompt
+
+            async with httpx.AsyncClient(timeout=300.0) as client:
+                response = await client.post(url, files=files, data=data)
+                response.raise_for_status()
+                result = response.json()
+
+            return WhisperTranscriptionResult(result)
+
+        except ImportError:
+            return WhisperTranscriptionResult({
+                "error": "httpx package not installed. Install with: pip install httpx",
+                "text": "",
+            })
+        except Exception as e:
+            return WhisperTranscriptionResult({
+                "error": f"Async HTTP transcription failed: {str(e)}",
+                "text": "",
+            })
+
+    def health_check(self) -> bool:
+        """
+        Check if the Whisper API is healthy and accessible.
+
+        Returns:
+            True if API is healthy, False otherwise
+        """
+        if not self.api_url:
+            return False
+
+        try:
+            import httpx
+
+            url = f"{self.api_url.rstrip('/')}/health"
+            with httpx.Client(timeout=10.0) as client:
+                response = client.get(url)
+                return response.status_code == 200
+
+        except Exception:
+            return False
+
+
+# Convenience function for quick transcription
+def transcribe(
+    audio: Union[str, Path, bytes],
+    api_url: Optional[str] = None,
+    model_size: str = "base",
+    language: Optional[str] = None,
+) -> WhisperTranscriptionResult:
+    """
+    Quick transcription function for simple use cases.
+
+    Args:
+        audio: Path to audio file or raw audio bytes
+        api_url: URL of Modal Whisper API (or set WHISPER_API_URL env var)
+        model_size: Whisper model size to use
+        language: Optional language code for transcription
+
+    Returns:
+        WhisperTranscriptionResult with transcription
+
+    Example:
+        >>> from src.whisper_client import transcribe
+        >>> result = transcribe("audio.mp3", language="en")
+        >>> print(result.text)
+    """
+    client = WhisperClient(api_url=api_url, model_size=model_size)
+    return client.transcribe(audio, language=language)
diff --git a/test_langsmith.py b/test_langsmith.py
new file mode 100644
index 0000000..53468c6
--- /dev/null
+++ b/test_langsmith.py
@@ -0,0 +1,18 @@
+from langchain_openai import ChatOpenAI
+import os
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Debug print to confirm the key is being loaded
+print("OPENAI KEY LOADED:", os.getenv("OPENAI_API_KEY")[:10], "...")
+
+# Initialize the OpenAI LLM
+llm = ChatOpenAI()
+
+# Send a basic test message
+response = llm.invoke("Hello, world!")
+
+# Output the response
+print("LLM RESPONSE:", response)
diff --git a/tests/test_whisper_integration.py b/tests/test_whisper_integration.py
new file mode 100644
index 0000000..ec228ad
--- /dev/null
+++ b/tests/test_whisper_integration.py
@@ -0,0 +1,277 @@
+"""
+Integration tests for Whisper Modal server
+
+These tests verify that the Whisper Modal server is properly deployed
+and functioning correctly.
+
+To run these tests:
+    pytest tests/test_whisper_integration.py -v
+
+Prerequisites:
+    - WHISPER_API_URL environment variable set
+    - Modal Whisper server deployed
+    - Test audio file available
+"""
+
+import os
+import pytest
+from pathlib import Path
+from dotenv import load_dotenv
+
+from src.whisper_client import WhisperClient, WhisperTranscriptionResult, transcribe
+
+# Load environment
+load_dotenv()
+
+
+@pytest.fixture
+def whisper_client():
+    """Create a WhisperClient instance for testing."""
+    return WhisperClient()
+
+
+@pytest.fixture
+def sample_audio():
+    """Path to sample audio file for testing.
+
+    Note: You'll need to provide an actual audio file for integration tests.
+    For unit tests, we can mock the API responses.
+    """
+    # Check for sample audio in test fixtures
+    test_audio = Path(__file__).parent / "fixtures" / "test_audio.mp3"
+
+    if test_audio.exists():
+        return str(test_audio)
+
+    # Fallback to project root
+    return "test_audio.mp3"
+
+
+class TestWhisperClient:
+    """Test WhisperClient functionality."""
+
+    def test_client_initialization(self):
+        """Test that client can be initialized."""
+        client = WhisperClient()
+        assert client is not None
+        assert client.model_size == "base"
+
+    def test_client_with_custom_model(self):
+        """Test client initialization with custom model size."""
+        client = WhisperClient(model_size="small")
+        assert client.model_size == "small"
+
+    def test_client_with_api_url(self):
+        """Test client initialization with API URL."""
+        api_url = "https://test.modal.run"
+        client = WhisperClient(api_url=api_url)
+        assert client.api_url == api_url
+
+    def test_client_reads_env_var(self):
+        """Test that client reads WHISPER_API_URL from environment."""
+        if os.getenv("WHISPER_API_URL"):
+            client = WhisperClient()
+            assert client.api_url == os.getenv("WHISPER_API_URL")
+
+
+class TestWhisperTranscriptionResult:
+    """Test WhisperTranscriptionResult data class."""
+
+    def test_successful_result(self):
+        """Test successful transcription result."""
+        data = {
+            "text": "This is a test transcription",
+            "language": "en",
+            "segments": [
+                {"text": "This is a test", "start": 0.0, "end": 1.5},
+                {"text": "transcription", "start": 1.5, "end": 2.5},
+            ],
+            "model_size": "base",
+        }
+
+        result = WhisperTranscriptionResult(data)
+
+        assert result.success is True
+        assert result.text == "This is a test transcription"
+        assert result.language == "en"
+        assert len(result.segments) == 2
+        assert result.model_size == "base"
+        assert result.error is None
+
+    def test_error_result(self):
+        """Test error transcription result."""
+        data = {
+            "error": "Transcription failed",
+            "text": "",
+        }
+
+        result = WhisperTranscriptionResult(data)
+
+        assert result.success is False
+        assert result.error == "Transcription failed"
+        assert result.text == ""
+
+    def test_result_string_representation(self):
+        """Test string representation of result."""
+        data = {"text": "Test", "language": "en"}
+        result = WhisperTranscriptionResult(data)
+
+        assert "Test" in str(result)
+        assert "en" in str(result)
+
+
+class TestWhisperIntegration:
+    """Integration tests requiring actual Whisper API."""
+
+    def test_health_check(self, whisper_client):
+        """Test API health check endpoint."""
+        if not os.getenv("WHISPER_API_URL"):
+            pytest.skip("WHISPER_API_URL not set")
+
+        is_healthy = whisper_client.health_check()
+        assert is_healthy is True, "Whisper API should be healthy"
+
+    def test_transcribe_missing_file(self, whisper_client):
+        """Test transcription of non-existent file."""
+        result = whisper_client.transcribe("nonexistent_file.mp3")
+
+        assert result.success is False
+        assert "not found" in result.error.lower()
+
+    @pytest.mark.skipif(
+        not os.getenv("WHISPER_API_URL"),
+        reason="WHISPER_API_URL not configured"
+    )
+    def test_transcribe_audio_file(self, whisper_client, sample_audio):
+        """Test actual audio transcription."""
+        if not Path(sample_audio).exists():
+            pytest.skip(f"Sample audio file not found: {sample_audio}")
+
+        result = whisper_client.transcribe(sample_audio)
+
+        # Should successfully transcribe
+        assert result.success is True, f"Transcription failed: {result.error}"
+        assert len(result.text) > 0, "Transcription text should not be empty"
+        assert result.language in ["en", "unknown"], "Should detect language"
+        assert len(result.segments) > 0, "Should have segments"
+
+    @pytest.mark.skipif(
+        not os.getenv("WHISPER_API_URL"),
+        reason="WHISPER_API_URL not configured"
+    )
+    def test_transcribe_with_language(self, whisper_client, sample_audio):
+        """Test transcription with specified language."""
+        if not Path(sample_audio).exists():
+            pytest.skip(f"Sample audio file not found: {sample_audio}")
+
+        result = whisper_client.transcribe(
+            sample_audio,
+            language="en"
+        )
+
+        assert result.success is True
+        assert result.language == "en"
+
+    @pytest.mark.skipif(
+        not os.getenv("WHISPER_API_URL"),
+        reason="WHISPER_API_URL not configured"
+    )
+    def test_transcribe_with_different_models(self, sample_audio):
+        """Test transcription with different model sizes."""
+        if not Path(sample_audio).exists():
+            pytest.skip(f"Sample audio file not found: {sample_audio}")
+
+        models = ["tiny", "base"]
+
+        for model_size in models:
+            client = WhisperClient(model_size=model_size)
+            result = client.transcribe(sample_audio)
+
+            assert result.success is True, f"Model {model_size} failed"
+            assert result.model_size == model_size
+            assert len(result.text) > 0
+
+    @pytest.mark.skipif(
+        not os.getenv("WHISPER_API_URL"),
+        reason="WHISPER_API_URL not configured"
+    )
+    def test_convenience_function(self, sample_audio):
+        """Test the convenience transcribe function."""
+        if not Path(sample_audio).exists():
+            pytest.skip(f"Sample audio file not found: {sample_audio}")
+
+        result = transcribe(sample_audio, language="en")
+
+        assert result.success is True
+        assert len(result.text) > 0
+
+
+class TestWhisperAsync:
+    """Test async functionality."""
+
+    @pytest.mark.asyncio
+    @pytest.mark.skipif(
+        not os.getenv("WHISPER_API_URL"),
+        reason="WHISPER_API_URL not configured"
+    )
+    async def test_async_transcription(self, sample_audio):
+        """Test async transcription."""
+        if not Path(sample_audio).exists():
+            pytest.skip(f"Sample audio file not found: {sample_audio}")
+
+        client = WhisperClient()
+        result = await client.transcribe_async(sample_audio)
+
+        assert result.success is True
+        assert len(result.text) > 0
+
+
+class TestErrorHandling:
+    """Test error handling scenarios."""
+
+    def test_no_api_url_configured(self):
+        """Test behavior when no API URL is configured."""
+        # Temporarily clear environment variable
+        original_url = os.environ.get("WHISPER_API_URL")
+        if "WHISPER_API_URL" in os.environ:
+            del os.environ["WHISPER_API_URL"]
+
+        client = WhisperClient()
+        result = client.transcribe("test.mp3")
+
+        # Should return error about missing API URL
+        assert result.success is False
+        assert "API URL" in result.error or "not found" in result.error
+
+        # Restore environment variable
+        if original_url:
+            os.environ["WHISPER_API_URL"] = original_url
+
+    def test_invalid_model_size_handled(self, whisper_client, sample_audio):
+        """Test that invalid model size is handled gracefully."""
+        if not Path(sample_audio).exists():
+            pytest.skip(f"Sample audio file not found: {sample_audio}")
+
+        # This should be caught by the API validation
+        result = whisper_client.transcribe(
+            sample_audio,
+            model_size="invalid_model"
+        )
+
+        # Should either fail or use default
+        # Exact behavior depends on API implementation
+        assert isinstance(result, WhisperTranscriptionResult)
+
+
+# Pytest configuration
+def pytest_configure(config):
+    """Configure pytest with custom markers."""
+    config.addinivalue_line(
+        "markers",
+        "integration: mark test as integration test requiring live API"
+    )
+
+
+if __name__ == "__main__":
+    # Run tests with pytest
+    pytest.main([__file__, "-v", "--tb=short"])
diff --git a/voicedform_graph.py b/voicedform_graph.py
new file mode 100644
index 0000000..02817e5
--- /dev/null
+++ b/voicedform_graph.py
@@ -0,0 +1,73 @@
+from dotenv import load_dotenv
+import os
+from langchain_openai import ChatOpenAI
+from langgraph.graph import StateGraph, END
+from langchain_core.runnables import RunnableLambda
+
+# ✅ Load environment
+load_dotenv()
+
+# ✅ DEBUG print to confirm key is loaded
+print("OPENAI_KEY LOADED:", os.getenv("OPENAI_API_KEY")[:10], "...")
+print("LangSmith project:", os.getenv("LANGSMITH_PROJECT"))
+
+# ✅ Reusable LLM
+llm = ChatOpenAI(model="gpt-4", temperature=0)
+
+# 🧠 Node: Supervisor (decides flow, stubbed for now)
+def supervisor_node(state: dict) -> dict:
+    print("🧭 Supervisor: Deciding flow...")
+    return {"form_type": "accident_report"}
+
+# 🧠 Node: Form Selector (uses LLM to describe form)
+def form_selector_node(state: dict) -> dict:
+    form_type = state.get("form_type", "unknown")
+    print(f"📄 Form Selector: Received form type → {form_type}")
+    message = f"You are helping complete a form of type: {form_type}. What's the first field?"
+    response = llm.invoke(message)
+    return {"form_type": form_type, "first_field": response.content}
+
+# 🧠 Node: Form Completion (mock interaction)
+def form_completion_node(state: dict) -> dict:
+    print(f"✍️ Form Completion: Starting with → {state.get('first_field')}")
+    response = llm.invoke("Let's pretend to fill out this form together.")
+    return {"form_complete": response.content}
+
+# 🧠 Node: Validator (trivial check for now)
+def validator_node(state: dict) -> dict:
+    print("✅ Validator: Verifying...")
+    is_valid = "form_complete" in state
+    return {"valid": is_valid}
+
+# ✅ Build the LangGraph DAG
+from typing import TypedDict, Optional
+
+class GraphState(TypedDict, total=False):
+    input: Optional[str]
+    form_type: Optional[str]
+    first_field: Optional[str]
+    form_complete: Optional[str]
+    valid: Optional[bool]
+
+graph = StateGraph(GraphState)
+
+
+graph.add_node("supervisor", RunnableLambda(supervisor_node))
+graph.add_node("form_selector", RunnableLambda(form_selector_node))
+graph.add_node("form_completion", RunnableLambda(form_completion_node))
+graph.add_node("validator", RunnableLambda(validator_node))
+
+# ⛓️ Wire nodes together
+graph.set_entry_point("supervisor")
+graph.add_edge("supervisor", "form_selector")
+graph.add_edge("form_selector", "form_completion")
+graph.add_edge("form_completion", "validator")
+graph.add_edge("validator", END)
+
+# ✅ Compile and Run
+dag = graph.compile()
+
+# 🧪 Invoke with empty state
+print("\n🧪 Running VoicedForm DAG...\n")
+output = dag.invoke({})
+print("\n🎉 Final output:", output)
diff --git a/voicedform_graph_with_audio.py b/voicedform_graph_with_audio.py
new file mode 100644
index 0000000..092e459
--- /dev/null
+++ b/voicedform_graph_with_audio.py
@@ -0,0 +1,348 @@
+"""
+VoicedForm Graph with Audio Transcription
+
+This is an enhanced version of the VoicedForm graph that includes audio transcription
+using the Modal Whisper server. It supports both voice and text input for form completion.
+
+The workflow now includes:
+1. Audio Transcription (optional) - Converts voice input to text
+2. Supervisor - Decides the form type based on input
+3. Form Selector - Determines required fields
+4. Form Completion - Interactive form filling
+5. Validator - Verifies completed form
+"""
+
+from dotenv import load_dotenv
+import os
+from typing import TypedDict, Optional
+from pathlib import Path
+
+from langchain_openai import ChatOpenAI
+from langgraph.graph import StateGraph, END
+from langchain_core.runnables import RunnableLambda
+
+from src.whisper_client import WhisperClient
+
+# Load environment
+load_dotenv()
+
+# DEBUG print to confirm keys are loaded
+print("OPENAI_KEY LOADED:", os.getenv("OPENAI_API_KEY")[:10] if os.getenv("OPENAI_API_KEY") else "NOT SET", "...")
+print("WHISPER_API_URL:", os.getenv("WHISPER_API_URL", "NOT SET"))
+print("LangSmith project:", os.getenv("LANGSMITH_PROJECT"))
+
+# Reusable LLM
+llm = ChatOpenAI(model="gpt-4", temperature=0)
+
+# Whisper client for audio transcription
+whisper_client = WhisperClient(
+    api_url=os.getenv("WHISPER_API_URL"),
+    model_size="base",  # Good balance of speed and accuracy
+)
+
+
+# Graph State Definition
+class GraphState(TypedDict, total=False):
+    """
+    State for the VoicedForm graph.
+
+    Attributes:
+        audio_file: Optional path to audio file for transcription
+        transcribed_text: Text transcribed from audio
+        user_input: Text input from user (either transcribed or direct)
+        form_type: Type of form to complete
+        form_fields: Fields required for the form
+        form_data: Collected form data
+        form_complete: Final completed form
+        valid: Whether the form is valid
+        error: Any error messages
+    """
+    audio_file: Optional[str]
+    transcribed_text: Optional[str]
+    user_input: Optional[str]
+    form_type: Optional[str]
+    form_fields: Optional[str]
+    form_data: Optional[dict]
+    form_complete: Optional[str]
+    valid: Optional[bool]
+    error: Optional[str]
+
+
+# Node: Audio Transcription
+def audio_transcription_node(state: GraphState) -> GraphState:
+    """
+    Transcribe audio file to text using Modal Whisper server.
+
+    This node is the entry point when audio input is provided. It converts
+    the audio to text and passes it to the next node in the workflow.
+
+    Args:
+        state: Graph state with audio_file path
+
+    Returns:
+        Updated state with transcribed_text and user_input
+    """
+    print("🎙️ Audio Transcription: Processing audio input...")
+
+    audio_file = state.get("audio_file")
+
+    # Skip if no audio file provided
+    if not audio_file:
+        print("⏭️ No audio file provided, skipping transcription")
+        return state
+
+    # Check if file exists
+    if not Path(audio_file).exists():
+        error_msg = f"Audio file not found: {audio_file}"
+        print(f"❌ {error_msg}")
+        return {**state, "error": error_msg}
+
+    # Transcribe audio
+    print(f"🎧 Transcribing: {audio_file}")
+    result = whisper_client.transcribe(
+        audio=audio_file,
+        language="en",  # Can be made dynamic based on user preference
+        task="transcribe",
+    )
+
+    if not result.success:
+        error_msg = f"Transcription failed: {result.error}"
+        print(f"❌ {error_msg}")
+        return {**state, "error": error_msg}
+
+    print(f"✅ Transcribed: {result.text}")
+    print(f"   Language: {result.language}")
+    print(f"   Segments: {len(result.segments)}")
+
+    return {
+        **state,
+        "transcribed_text": result.text,
+        "user_input": result.text,  # Use transcribed text as user input
+    }
+
+
+# Node: Supervisor (enhanced with context from user input)
+def supervisor_node(state: GraphState) -> GraphState:
+    """
+    Supervisor decides the form type based on user input.
+
+    This node analyzes the user's input (transcribed or text) to determine
+    what type of form they need to complete.
+
+    Args:
+        state: Graph state with user_input
+
+    Returns:
+        Updated state with form_type
+    """
+    print("🧭 Supervisor: Analyzing input to determine form type...")
+
+    user_input = state.get("user_input", "")
+
+    if user_input:
+        # Use LLM to determine form type from user input
+        prompt = f"""Based on the following user input, determine what type of form they need to complete.
+
+User input: "{user_input}"
+
+Common form types: accident_report, contact_form, feedback_form, survey, registration
+
+Respond with just the form type, nothing else."""
+
+        response = llm.invoke(prompt)
+        form_type = response.content.strip().lower()
+        print(f"📋 Determined form type: {form_type}")
+    else:
+        # Default form type
+        form_type = "accident_report"
+        print(f"📋 Using default form type: {form_type}")
+
+    return {**state, "form_type": form_type}
+
+
+# Node: Form Selector (uses LLM to describe form)
+def form_selector_node(state: GraphState) -> GraphState:
+    """
+    Form Selector determines the required fields for the form.
+
+    Based on the form type, this node uses an LLM to identify what
+    fields need to be collected.
+
+    Args:
+        state: Graph state with form_type
+
+    Returns:
+        Updated state with form_fields
+    """
+    form_type = state.get("form_type", "unknown")
+    print(f"📄 Form Selector: Processing form type → {form_type}")
+
+    message = f"""You are helping complete a form of type: {form_type}.
+
+List the required fields for this form. Be specific and practical.
+For example, an accident report might need: date, location, description, injuries, witnesses."""
+
+    response = llm.invoke(message)
+    form_fields = response.content
+
+    print(f"📝 Required fields identified:\n{form_fields}")
+
+    return {**state, "form_fields": form_fields}
+
+
+# Node: Form Completion (enhanced with user input context)
+def form_completion_node(state: GraphState) -> GraphState:
+    """
+    Form Completion handles the interactive form filling process.
+
+    This node uses the user's input and the required fields to start
+    populating the form.
+
+    Args:
+        state: Graph state with form_fields and user_input
+
+    Returns:
+        Updated state with form_complete
+    """
+    print("✍️ Form Completion: Starting form population...")
+
+    form_fields = state.get("form_fields", "")
+    user_input = state.get("user_input", "")
+
+    prompt = f"""You are helping to complete a form. Here are the required fields:
+
+{form_fields}
+
+The user has provided the following input:
+"{user_input}"
+
+Based on this input, extract and organize the information to fill out as many fields as possible.
+Format the response as a completed form with field names and values."""
+
+    response = llm.invoke(prompt)
+    form_complete = response.content
+
+    print(f"📋 Form populated:\n{form_complete[:200]}...")
+
+    return {**state, "form_complete": form_complete}
+
+
+# Node: Validator (verifies form completion)
+def validator_node(state: GraphState) -> GraphState:
+    """
+    Validator checks if the form is properly completed.
+
+    This node verifies that all required fields have been filled
+    and the form is ready for submission.
+
+    Args:
+        state: Graph state with form_complete
+
+    Returns:
+        Updated state with valid flag
+    """
+    print("✅ Validator: Verifying form completion...")
+
+    form_complete = state.get("form_complete", "")
+    is_valid = bool(form_complete and len(form_complete) > 20)
+
+    if is_valid:
+        print("✅ Form is valid and complete!")
+    else:
+        print("❌ Form validation failed - incomplete data")
+
+    return {**state, "valid": is_valid}
+
+
+# Build the LangGraph workflow
+graph = StateGraph(GraphState)
+
+# Add nodes
+graph.add_node("audio_transcription", RunnableLambda(audio_transcription_node))
+graph.add_node("supervisor", RunnableLambda(supervisor_node))
+graph.add_node("form_selector", RunnableLambda(form_selector_node))
+graph.add_node("form_completion", RunnableLambda(form_completion_node))
+graph.add_node("validator", RunnableLambda(validator_node))
+
+# Wire nodes together
+graph.set_entry_point("audio_transcription")
+graph.add_edge("audio_transcription", "supervisor")
+graph.add_edge("supervisor", "form_selector")
+graph.add_edge("form_selector", "form_completion")
+graph.add_edge("form_completion", "validator")
+graph.add_edge("validator", END)
+
+# Compile the graph
+dag = graph.compile()
+
+
+# Convenience functions for running the workflow
+def process_voice_input(audio_file: str) -> dict:
+    """
+    Process a voice input file through the VoicedForm workflow.
+
+    Args:
+        audio_file: Path to audio file
+
+    Returns:
+        Final state with completed form
+
+    Example:
+        >>> result = process_voice_input("user_recording.mp3")
+        >>> print(result["form_complete"])
+    """
+    print(f"\n🎙️ Processing voice input from: {audio_file}\n")
+    return dag.invoke({"audio_file": audio_file})
+
+
+def process_text_input(user_text: str) -> dict:
+    """
+    Process a text input through the VoicedForm workflow.
+
+    Args:
+        user_text: User's text input
+
+    Returns:
+        Final state with completed form
+
+    Example:
+        >>> result = process_text_input("I had an accident on Main St today")
+        >>> print(result["form_complete"])
+    """
+    print(f"\n💬 Processing text input: {user_text}\n")
+    return dag.invoke({"user_input": user_text})
+
+
+# Main execution for testing
+if __name__ == "__main__":
+    import sys
+
+    print("\n🚀 VoicedForm Graph with Audio Transcription\n")
+    print("=" * 80)
+
+    # Example 1: Text input
+    print("\n📝 Example 1: Text Input")
+    print("-" * 80)
+    text_result = process_text_input(
+        "I need to report an accident that happened on Main Street today at 2pm. "
+        "A car hit a pedestrian, there were minor injuries, and two witnesses."
+    )
+    print("\n📊 Result:")
+    print(f"Form Type: {text_result.get('form_type')}")
+    print(f"Valid: {text_result.get('valid')}")
+    print(f"Form:\n{text_result.get('form_complete', 'N/A')[:300]}...")
+
+    # Example 2: Audio input (if file provided)
+    if len(sys.argv) > 1:
+        audio_file = sys.argv[1]
+        print(f"\n🎙️ Example 2: Audio Input from {audio_file}")
+        print("-" * 80)
+        audio_result = process_voice_input(audio_file)
+        print("\n📊 Result:")
+        print(f"Transcribed: {audio_result.get('transcribed_text', 'N/A')}")
+        print(f"Form Type: {audio_result.get('form_type')}")
+        print(f"Valid: {audio_result.get('valid')}")
+        print(f"Form:\n{audio_result.get('form_complete', 'N/A')[:300]}...")
+
+    print("\n" + "=" * 80)
+    print("✅ VoicedForm workflow complete!")