Automatic Call Summarization with Claude: Practical Guide

Why Automatic Call Summarization?

The use cases are massive:

• →Call centers: each agent handles 40-60 calls/day. Manual post-processing represents 20-30% of work time.
• →Sales teams: incomplete sales notes lose context between follow-ups.
• →Corporate meetings: verbal decisions are often forgotten without structured written records.

Call summarisation in production: what quietly fails

Automatic call summarisation is one of the most common enterprise LLM use cases, and also one where "it worked in the demo" masks real production pain. The threads on r/MachineLearning, r/salesforce, r/SalesTechniques, and r/dataengineering map out what teams actually hit.

What ships reliably:

• →Structured summaries over free-form ones. A fixed schema (executive summary, participants, decisions, action items, sentiment) beats open-ended "summarise this call" for downstream systems.
• →Chunking + map-reduce for long calls. A 90-minute call exceeds most single-prompt budgets. Map-reduce summarisation patterns and hierarchical summarisation are the proven approach.
• →ASR quality sets the ceiling. AssemblyAI, Deepgram, OpenAI Whisper, and Google Speech-to-Text all have honest limits on noisy audio, heavy accents, and overlapping speakers. Garbage-in garbage-out applies here more than most places.
• →Diarisation errors propagate. If speaker attribution is wrong in the transcript, the summary will attribute decisions to the wrong person. Validate diarisation on your audio profile.

What quietly fails:

• →Hallucinated action items. Models will invent concrete action items from vague discussion. Production teams add verification steps: does this action item appear as a literal quote, paraphrase with grounding, or a pure inference? Log and flag inferences.
• →Consent and compliance. GDPR, CCPA, and industry-specific rules (HIPAA for healthcare, FINRA for financial services) constrain what can be recorded, stored, and processed. Otter.ai, Fireflies, and Gong all publish their consent frameworks; read them.
• →Sentiment analysis is fragile. "Customer was frustrated" vs "customer had questions" can be a single word flip that changes the CRM routing. Treat sentiment outputs as soft signals.
• →PII handling is non-negotiable. Card numbers, SSNs, medical details appearing in calls need scrubbing before logging. Presidio or regex-based redaction is standard.
• →Cost creeps with volume. Summarising every call gets expensive fast. Message batching and prompt caching are meaningful here.

What production teams actually do:

• →Two-pass: extract then summarise. First pass pulls structured facts (speakers, decisions, commitments); second pass synthesises. More reliable than one-shot summaries.
• →Evaluate against reference summaries. ROUGE and BERTScore are weak proxies; human-rated A/B evals are the ground truth.
• →Couple with CRM write-back carefully. Automatic writes to Salesforce or HubSpot are high-risk until summary quality is measured at 95%+ accuracy. Start with human-in-the-loop.
• →Instrument hallucination rate. Langfuse and Arize support tracking output-vs-source-text grounding.

The honest framing: call summarisation looks easy in demos and is operationally complex in production. The wins come from structured outputs, validation loops, PII hygiene, and honest evaluation against ground truth. Skip those and the demo magic becomes a pipeline of silent errors that poison downstream systems.

Transcript Pre-processing

Before sending a transcript to Claude, cleanup is essential. Raw transcripts from ASR (Automatic Speech Recognition) contain noise: hesitations, repetitions, diarization errors.

Cleanup and normalization

import re
from dataclasses import dataclass

@dataclass
class TranscriptSegment:
    speaker: str
    text: str
    start_time: float
    end_time: float

def clean_transcript(segments: list[TranscriptSegment]) -> list[TranscriptSegment]:
    """Clean a raw ASR transcript."""
    cleaned = []
    for seg in segments:
        text = seg.text.strip()
        # Remove common hesitations
        text = re.sub(r'\b(um|uh|ah|oh|like|you know)\b', '', text, flags=re.IGNORECASE)
        # Remove consecutive repetitions
        text = re.sub(r'\b(\w+)( \1\b)+', r'\1', text)
        # Normalize whitespace
        text = re.sub(r'\s+', ' ', text).strip()
        if text:
            cleaned.append(TranscriptSegment(
                speaker=seg.speaker,
                text=text,
                start_time=seg.start_time,
                end_time=seg.end_time
            ))
    return cleaned

def merge_consecutive_speaker(segments: list[TranscriptSegment]) -> list[TranscriptSegment]:
    """Merge consecutive segments from the same speaker."""
    if not segments:
        return []
    merged = [segments[0]]
    for seg in segments[1:]:
        if seg.speaker == merged[-1].speaker:
            merged[-1].text += " " + seg.text
            merged[-1].end_time = seg.end_time
        else:
            merged.append(seg)
    return merged

Multi-speaker diarization handling

When diarization is uncertain (misidentified speakers), Claude can help correct it:

import anthropic

client = anthropic.Anthropic()

def fix_diarization(transcript_text: str) -> str:
    """Use Claude to correct diarization errors."""
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=4096,
        messages=[{
            "role": "user",
            "content": f"""Analyze this transcript and correct diarization errors
(wrong speaker attribution).

Clues to identify errors:
- A speaker responding to themselves
- Inconsistent tone/topic change for the same speaker
- Politeness formulas attributed to the wrong person

Transcript:
{transcript_text}

Return the corrected transcript in the same format."""
        }]
    )
    return response.content[0].text

Prompt Design for Structured Summarization

The core of the system is the prompt that transforms a transcript into a structured summary. The key: an explicit output template adapted to the call type.

Generic template (meeting / call)

SUMMARIZATION_PROMPT = """You are an assistant specialized in summarizing
professional calls. Produce a structured summary faithful to the transcript.

RULES:
- Never invent information absent from the transcript
- Attribute each decision/action to the correct speaker
- Distinguish firm decisions from exploratory discussions
- Use the output format EXACTLY as specified

OUTPUT FORMAT:
## Executive Summary
[2-3 sentences summarizing the objective and main outcome of the call]

## Participants
- [Name/Role]: [Main contribution]

## Key Points Discussed
1. [Topic] — [Conclusion or status]
2. ...

## Decisions Made
- [Decision] (by [Speaker], at [timestamp if available])

## Action Items
| Responsible | Action | Deadline | Priority |
|-------------|--------|----------|----------|
| [Name] | [Description] | [Date/Timeframe] | High/Medium/Low |

## Next Steps
- [Step] — [Responsible] — [Target date]

## Overall Tone and Sentiment
[1 sentence about the general atmosphere of the call]

---
TRANSCRIPT:
{transcript}"""

BANT template for sales calls

SALES_CALL_PROMPT = """You are an AI sales analyst. Summarize this sales call
in BANT format for the CRM.

OUTPUT FORMAT:
## Sales Call Summary

### Client Information
- Company: [name]
- Contact: [name, role]
- Industry: [sector]

### BANT Qualification
- **Budget**: [Amount mentioned or "Not discussed"]
- **Authority**: [Decision-maker identified? Who?]
- **Need**: [Primary need expressed]
- **Timeline**: [Deadline mentioned or "Not defined"]

### Qualification Score
[1-10 with justification]

### Objections Raised
1. [Objection] → [Response provided]

### Sales Action Items
| Action | Responsible | Deadline |
|--------|-------------|----------|
| [Description] | [Seller/Client] | [Date] |

### Recommended Next Step
[Recommendation based on BANT analysis]

---
TRANSCRIPT:
{transcript}"""

API Call and Structured Extraction

Here is the complete implementation to send a transcript and retrieve a structured summary:

import anthropic
import json

client = anthropic.Anthropic()

def summarize_call(transcript: str, call_type: str = "generic") -> dict:
    """Summarize a call and return a structured summary."""
    
    prompts = {
        "generic": SUMMARIZATION_PROMPT,
        "sales": SALES_CALL_PROMPT,
    }
    prompt_template = prompts.get(call_type, SUMMARIZATION_PROMPT)
    
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=4096,
        messages=[{
            "role": "user",
            "content": prompt_template.format(transcript=transcript)
        }]
    )
    
    summary_text = response.content[0].text
    
    # Extract action items as structured JSON
    action_response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=2048,
        messages=[{
            "role": "user",
            "content": f"""Extract the action items from this summary as strict JSON.

Summary:
{summary_text}

Return ONLY valid JSON in this format:
{{
  "action_items": [
    {{
      "responsible": "Name",
      "action": "Description",
      "deadline": "Date or null",
      "priority": "high|medium|low"
    }}
  ],
  "decisions": [
    {{
      "decision": "Description",
      "made_by": "Name",
      "timestamp": "Moment in the call or null"
    }}
  ],
  "follow_ups": [
    {{
      "description": "Description",
      "responsible": "Name",
      "target_date": "Date or null"
    }}
  ]
}}"""
        }]
    )
    
    structured_data = json.loads(action_response.content[0].text)
    
    return {
        "summary": summary_text,
        "structured": structured_data,
        "model": "claude-sonnet-4-20250514",
        "call_type": call_type
    }

For more on reliable JSON extraction, see our Structured Outputs guide.

Handling Long Calls: Chunking + Map-Reduce

Calls over 30 minutes often exceed the optimal context window. The solution: a map-reduce pattern inspired by prompt chaining pipelines.

Chunking implementation with overlap

def chunk_transcript(
    segments: list[TranscriptSegment],
    chunk_duration_minutes: float = 15.0,
    overlap_minutes: float = 3.0
) -> list[list[TranscriptSegment]]:
    """Split a transcript into chunks with overlap."""
    chunk_duration = chunk_duration_minutes * 60
    overlap = overlap_minutes * 60
    
    if not segments:
        return []
    
    total_duration = segments[-1].end_time - segments[0].start_time
    chunks = []
    start_time = segments[0].start_time
    
    while start_time < segments[-1].end_time:
        end_time = start_time + chunk_duration
        chunk = [s for s in segments 
                 if s.start_time >= start_time and s.start_time < end_time]
        if chunk:
            chunks.append(chunk)
        start_time += chunk_duration - overlap
    
    return chunks

def format_chunk(segments: list[TranscriptSegment]) -> str:
    """Format a chunk for sending to Claude."""
    lines = []
    for seg in segments:
        minutes = int(seg.start_time // 60)
        seconds = int(seg.start_time % 60)
        lines.append(f"[{minutes:02d}:{seconds:02d}] {seg.speaker}: {seg.text}")
    return "\n".join(lines)

Map-Reduce: parallel summarization then merge

import asyncio

async def summarize_chunk(client, chunk_text: str, chunk_index: int, 
                          total_chunks: int) -> str:
    """Summarize an individual chunk (MAP phase)."""
    response = await client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=2048,
        messages=[{
            "role": "user",
            "content": f"""Summarize this call segment (part {chunk_index + 1}/{total_chunks}).

IMPORTANT: This is only a PART of the call. Do not conclude
prematurely. Note ongoing topics at the end of the segment.

Extract:
- Key points discussed
- Decisions made (with speaker)
- Action items identified
- Ongoing / unresolved topics

Segment:
{chunk_text}"""
        }]
    )
    return response.content[0].text

async def merge_summaries(client, partial_summaries: list[str], 
                          call_type: str = "generic") -> str:
    """Merge partial summaries into final summary (REDUCE phase)."""
    summaries_text = "\n\n---\n\n".join(
        [f"### Part {i+1}\n{s}" for i, s in enumerate(partial_summaries)]
    )
    
    response = await client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=4096,
        messages=[{
            "role": "user",
            "content": f"""Merge these partial summaries into ONE coherent final summary.

MERGE RULES:
- Deduplicate information present in overlap zones
- Maintain chronological order
- Consolidate action items (one item = one entry, even if it appears
  in multiple parts)
- Resolve "ongoing" topics with their conclusion in subsequent parts

Partial summaries:
{summaries_text}

Produce the final summary in the standard structured format."""
        }]
    )
    return response.content[0].text

async def summarize_long_call(transcript_segments: list[TranscriptSegment],
                               call_type: str = "generic") -> dict:
    """Complete pipeline for long calls."""
    client = anthropic.AsyncAnthropic()
    
    # Chunking
    chunks = chunk_transcript(transcript_segments)
    chunk_texts = [format_chunk(c) for c in chunks]
    
    # MAP phase: parallel summaries
    tasks = [
        summarize_chunk(client, text, i, len(chunk_texts))
        for i, text in enumerate(chunk_texts)
    ]
    partial_summaries = await asyncio.gather(*tasks)
    
    # REDUCE phase: merge
    final_summary = await merge_summaries(client, partial_summaries, call_type)
    
    return {
        "summary": final_summary,
        "chunks_processed": len(chunks),
        "method": "map-reduce"
    }

Summary Quality Evaluation

A good summary must be faithful, complete, and concise. Here is an automatic evaluation system.

Automated evaluation with Claude-as-a-Judge

def evaluate_summary(transcript: str, summary: str) -> dict:
    """Evaluate a summary on 3 dimensions: faithfulness, completeness, conciseness."""
    
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=2048,
        messages=[{
            "role": "user",
            "content": f"""Evaluate this call summary on 3 dimensions.
For each dimension, provide a score from 0.0 to 1.0 and a justification.

## Dimensions

1. **Faithfulness**: Is each claim in the summary verifiable in the
   transcript? (No hallucination)
2. **Completeness**: Are all key points, decisions, and actions from
   the transcript present in the summary?
3. **Conciseness**: Is the summary sufficiently condensed without
   redundancy or superfluous details?

## Transcript (source of truth)
{transcript[:3000]}

## Summary to evaluate
{summary}

Return ONLY valid JSON:
{{
  "faithfulness": {{"score": 0.0, "issues": []}},
  "completeness": {{"score": 0.0, "missing": []}},
  "conciseness": {{"score": 0.0, "redundancies": []}},
  "overall_score": 0.0,
  "pass": true
}}"""
        }]
    )
    
    return json.loads(response.content[0].text)

Re-generation loop if quality is insufficient

async def summarize_with_quality_check(
    transcript: str, 
    call_type: str = "generic",
    max_retries: int = 2,
    quality_threshold: float = 0.8
) -> dict:
    """Summarize with quality check and re-generation if needed."""
    
    for attempt in range(max_retries + 1):
        result = summarize_call(transcript, call_type)
        evaluation = evaluate_summary(transcript, result["summary"])
        
        if evaluation["overall_score"] >= quality_threshold:
            return {
                **result,
                "quality": evaluation,
                "attempts": attempt + 1
            }
        
        # Feedback to improve the next attempt
        if evaluation["completeness"]["missing"]:
            transcript = f"""[ADDITIONAL INSTRUCTION]
Points missed in the previous attempt:
{', '.join(evaluation['completeness']['missing'])}
Make sure to include these elements.

{transcript}"""
    
    # Return last result even if below threshold
    return {**result, "quality": evaluation, "attempts": max_retries + 1}

Case Study: Sales Call → CRM Summary

Complete Production Pipeline

Here is the final pipeline assembly, integrating all steps:

import anthropic
import asyncio
from dataclasses import asdict

async def production_pipeline(
    raw_segments: list[TranscriptSegment],
    call_type: str = "generic",
    call_metadata: dict = None
) -> dict:
    """Production pipeline for call summarization."""
    
    # 1. Pre-processing
    cleaned = clean_transcript(raw_segments)
    merged = merge_consecutive_speaker(cleaned)
    
    # 2. Determine strategy (direct or map-reduce)
    total_duration = merged[-1].end_time - merged[0].start_time
    
    if total_duration > 30 * 60:  # > 30 minutes
        result = await summarize_long_call(merged, call_type)
    else:
        transcript_text = format_chunk(merged)
        result = summarize_call(transcript_text, call_type)
    
    # 3. Quality evaluation
    transcript_for_eval = format_chunk(merged[:50])  # First segments
    evaluation = evaluate_summary(transcript_for_eval, result["summary"])
    
    return {
        "call_metadata": call_metadata,
        "summary": result["summary"],
        "structured_data": result.get("structured", {}),
        "quality": evaluation,
        "processing": {
            "method": result.get("method", "direct"),
            "segments_processed": len(merged),
            "duration_minutes": round(total_duration / 60, 1)
        }
    }

For more advanced pipeline architectures, see our prompt chaining guide. For using Extended Thinking on complex transcripts, see the Extended Thinking guide.

FAQ

How does Claude handle very long transcripts (over one hour)?

For transcripts exceeding the context window, we use a map-reduce pattern: the transcript is split into 10-15 minute chunks with overlap, each chunk is summarized independently, then partial summaries are merged into a coherent final summary with action extraction.

How accurate is Claude's action item extraction?

With a well-structured prompt and strict output format, Claude achieves 90-95% recall on explicit action items and 75-85% on implicit commitments. Accuracy improves significantly with few-shot examples in the prompt.

How do you handle transcripts with diarization errors (wrong speaker attribution)?

A pre-processing step corrects diarization inconsistencies by analyzing conversational context. Claude can identify when a speaker is misattributed based on semantic content and thematic transitions.

Can the summary format be customized per call type (sales, support, meeting)?

Yes, we use specialized output templates: BANT for sales calls, SOAP-like for technical support, and a decision/action format for meetings. The system prompt automatically selects the template via an initial classifier.