Summarizer Agent

The Summarizer Agent transforms analysis results into natural, human-readable responses with configurable formats, tones, and styles using template-based generation and LLM-enhanced summarization.

What It Does

The Summarizer Agent is the fourth stage of the agent pipeline:

Analysis (Insights + Entities + Anomalies) → SUMMARIZER → Natural Language Response

Input: Analysis from Analyzer, query context, tools used
Output: AgentResponse with natural language message

Summarization Strategies

Template-Based (Fast)

Predefined templates for common response patterns:

Performance: 10-50ms
Consistency: Highly predictable format
Use case: Real-time responses, structured outputs

// Template example
template = `Found ${insights.length} insights from ${tools.length} tools.
${insights.map(i => `- ${i.description}`).join('\n')}`;

LLM-Based (Intelligent)

AI-powered summarization for natural responses:

Performance: 1-3 seconds
Quality: Natural, contextual, adaptive
Use case: User-facing responses, reports

// LLM generates: 
"Your analysis revealed 3 contaminated shipments from last week, 
with Lead being the primary concern (2 occurrences). The contamination 
rate of 60% is significantly higher than normal and requires immediate attention."

Hybrid (Recommended)

Template for structure, LLM for enhancement:

// 1. Generate structured summary with template
const structure = buildTemplateSummary(analysis);

// 2. Enhance with LLM for natural flow
const enhanced = await enhanceWithLLM(structure, query);

// 3. Return combined result
return { message: enhanced, ... };

Configuration Options

interface SummarizerConfig {
  format: "plain" | "markdown" | "json";  // Output format
  tone: "professional" | "technical" | "casual";  // Response tone
  maxLength: number;                      // Max response characters
  includeSupportingData: boolean;         // Include raw data
}

// Create with custom config
const summarizer = new SummarizerAgent(llm, {
  format: "markdown",
  tone: "professional",
  maxLength: 500,
  includeSupportingData: true
});

Format Options

Plain Text Format

Simple, readable text output:

const plainSummarizer = new SummarizerAgent(llm, {
  format: "plain"
});

const response = await plainSummarizer.summarize(query, analysis, tools);

console.log(response.message);
// Output:
// "Found 5 contaminated shipments from last week. High contamination 
// rate: 60% of shipments have contaminants. Most common contaminant: 
// Lead (3 occurrences). Immediate attention required for 2 high-risk items."

Markdown Format

Structured output with formatting:

const markdownSummarizer = new SummarizerAgent(llm, {
  format: "markdown"
});

const response = await markdownSummarizer.summarize(query, analysis, tools);

console.log(response.message);
// Output:
// "## Contaminated Shipments Analysis
//
// ### Summary
// Found **5 contaminated shipments** from last week.
//
// ### Key Insights
// - High contamination rate: **60%** of shipments
// - Most common: **Lead** (3 occurrences)
// - Risk level: **2 high-risk** items
//
// ### Recommendations
// Immediate attention required for high-risk contaminants."

JSON Format

Structured data output:

const jsonSummarizer = new SummarizerAgent(llm, {
  format: "json"
});

const response = await jsonSummarizer.summarize(query, analysis, tools);

console.log(JSON.parse(response.message));
// Output:
// {
//   "summary": "Found 5 contaminated shipments",
//   "metrics": {
//     "total_shipments": 5,
//     "contamination_rate": 0.6,
//     "high_risk_count": 2
//   },
//   "recommendations": ["Immediate attention required"]
// }

Tone Control

Professional Tone

Formal, business-appropriate language:

const professionalSummarizer = new SummarizerAgent(llm, {
  tone: "professional"
});

const response = await professionalSummarizer.summarize(query, analysis, tools);

// Output:
// "The analysis identified 5 contaminated shipments during the specified 
// period. The contamination rate of 60% exceeds acceptable thresholds 
// and warrants immediate investigation. Lead contaminants account for 
// 60% of detected substances, indicating a systematic issue requiring 
// corrective action."

Technical Tone

Detailed, metric-focused language:

const technicalSummarizer = new SummarizerAgent(llm, {
  tone: "technical"
});

const response = await technicalSummarizer.summarize(query, analysis, tools);

// Output:
// "Query executed shipments_list tool (execution time: 45ms). Dataset: 
// n=5 shipments, contamination_rate=0.60, μ_concentration=245ppm, 
// σ=125ppm. Outlier detection (threshold=2σ) identified 1 anomaly 
// (z-score=3.2). Primary contaminant: Lead (60% prevalence, 
// risk_level=high)."

Casual Tone

Friendly, conversational language:

const casualSummarizer = new SummarizerAgent(llm, {
  tone: "casual"
});

const response = await casualSummarizer.summarize(query, analysis, tools);

// Output:
// "Hey! So I found 5 shipments with contamination issues from last week. 
// The contamination rate is pretty high at 60% - definitely something 
// to look into. Lead seems to be the main culprit, showing up in 3 of 
// them. A couple of these are high-risk, so you'll want to deal with 
// those ASAP."

Response Examples

Example 1: Simple Data Query

Input:

query = "Get shipments";
analysis = {
  summary: "Found 10 shipments",
  insights: [
    { type: "trend", description: "Low contamination rate: 10%", confidence: 0.85 }
  ],
  entities: [/* 10 shipments */],
  anomalies: []
};
tools = ["shipments_list"];

Output:

{
  message: "Found 10 shipments in the system. Analysis shows a low contamination rate of 10%, which is within acceptable parameters.",
  tools_used: ["shipments_list"],
  data: [/* raw shipment data */],
  analysis: { /* full analysis */ },
  metadata: { /* request metadata */ }
}

Example 2: Complex Analysis with Anomalies

Input:

query = "Analyze contamination patterns";
analysis = {
  summary: "Analyzed contamination across facilities",
  insights: [
    { type: "pattern", description: "Berlin facilities show 40% higher contamination", confidence: 0.88 },
    { type: "correlation", description: "CarrierA shipments have 3x contamination rate", confidence: 0.92 }
  ],
  entities: [/* facilities and shipments */],
  anomalies: [
    { type: "outlier", description: "Facility F1 has 95% contamination rate", severity: "critical" }
  ]
};
tools = ["facilities_list", "shipments_list", "contaminants_list"];

Output:

{
  message: "Analysis of contamination patterns revealed significant findings. 
  Berlin facilities demonstrate 40% higher contamination rates compared to other regions (confidence: 88%). 
  Additionally, shipments from CarrierA show 3x higher contamination rates than average (confidence: 92%). 
  
  ⚠️ Critical anomaly detected: Facility F1 is experiencing a 95% contamination rate, 
  significantly exceeding normal parameters. Immediate investigation and corrective action recommended.",
  
  tools_used: ["facilities_list", "shipments_list", "contaminants_list"],
  analysis: { /* full analysis */ }
}

Example 3: No Data Found

Input:

query = "Get shipments from NonExistentFacility";
analysis = {
  summary: "No data found",
  insights: [],
  entities: [],
  anomalies: []
};
tools = ["facilities_list", "shipments_list"];

Output:

{
  message: "No shipments were found from NonExistentFacility. The facility may not exist in the system, or there may be no shipments associated with it.",
  tools_used: ["facilities_list", "shipments_list"],
  data: []
}

Example 4: Many Insights

Input:

analysis = {
  insights: [
    { type: "trend", description: "Insight 1...", confidence: 0.9 },
    { type: "pattern", description: "Insight 2...", confidence: 0.85 },
    { type: "correlation", description: "Insight 3...", confidence: 0.92 },
    // ... 10 more insights
  ]
};

Output (LLM organizes into coherent summary):

"Comprehensive analysis revealed multiple significant findings:

**Primary Trends:**
- Insight 1... (confidence: 90%)
- Insight 4... (confidence: 87%)

**Key Patterns:**
- Insight 2... (confidence: 85%)
- Insight 5... (confidence: 83%)

**Correlations:**
- Insight 3... (confidence: 92%)

The data suggests systematic issues requiring strategic intervention."

LLM Enhancement

Enhancement Process

async function enhanceWithLLM(
  templateSummary: string,
  analysis: Analysis,
  query: string
): Promise<string> {
  const prompt = `
    Original query: "${query}"
    
    Template summary: "${templateSummary}"
    
    Analysis details:
    - ${analysis.insights.length} insights found
    - ${analysis.anomalies.length} anomalies detected
    - ${analysis.entities.length} entities identified
    
    Generate a natural, fluent summary that:
    1. Directly answers the user's query
    2. Highlights most important insights
    3. Mentions critical anomalies
    4. Uses clear, professional language
    5. Is concise but complete
  `;

  const response = await llm.generate({ messages: [{ role: "user", content: prompt }] });
  return response.content;
}

LLM Fallback

// If LLM fails, falls back to template
async summarize(query, analysis, tools) {
  try {
    // Try LLM enhancement
    const enhanced = await enhanceWithLLM(analysis);
    return createResponse(enhanced);
  } catch (error) {
    // Fallback to template
    console.log('LLM failed, using template fallback');
    const template = buildTemplateSummary(analysis);
    return createResponse(template);
  }
}

API Reference