Module 6: Capstone Project - The Business Analyst Agent
Building a Production-Ready Autonomous Agent
Introduction: Bringing It All Together
You've learned:
- How to build agents (Module 1)
- How to give them tools (Module 2)
- How to orchestrate complex workflows (Module 3)
- How to add memory and research capabilities (Module 4)
- How to build beautiful interfaces (Module 5)
Now it's time to combine everything into a real, production-ready application.
The Mission
Build a Financial Research Agent that can autonomously:
- Search the web for a company's latest earnings report
- Read and extract key financial metrics
- Analyze the risks and opportunities
- Draft a professional email memo
- Request human approval before sending
- Send the email via API
User command:
"Research Tesla's Q4 earnings, analyze the risks, and email me a summary."
Agent executes:
┌─────────────────┐
│ Search Web │ Find Tesla Q4 earnings report
└────────┬────────┘
│
┌────────▼────────┐
│ Scrape Page │ Extract report content
└────────┬────────┘
│
┌────────▼────────┐
│ Analyze Risks │ Use LLM to identify risks
└────────┬────────┘
│
┌────────▼────────┐
│ Draft Email │ Generate professional memo
└────────┬────────┘
│
┌────────▼────────┐
│ Show to User │ "Review this draft before I send"
└────────┬────────┘
│
[User Approves]
│
┌────────▼────────┐
│ Send Email │ Via Resend/SendGrid
└─────────────────┘
Architecture Overview
Tech Stack:
- Frontend: Next.js 16 (App Router)
- AI: Vercel AI SDK + OpenAI
- Orchestration: LangGraph
- Search: Tavily API
- Scraping: Firecrawl
- Email: Resend
- Deployment: Vercel
File Structure:
business-analyst-agent/
├── app/
│ ├── api/
│ │ ├── agent/route.ts # Main agent endpoint
│ │ └── send-email/route.ts # Email sending
│ └── page.tsx # UI
├── lib/
│ ├── agent/
│ │ ├── graph.ts # LangGraph workflow
│ │ ├── nodes.ts # Agent nodes
│ │ └── tools.ts # Research tools
│ ├── services/
│ │ ├── research.ts # Web search/scraping
│ │ └── email.ts # Email service
│ └── types.ts # TypeScript types
└── components/
├── AgentChat.tsx
├── DraftPreview.tsx
└── ApprovalModal.tsx
Step 1: Setup
npx create-next-app@latest business-analyst-agent
cd business-analyst-agent
npm install ai @ai-sdk/react @ai-sdk/openai @langchain/langgraph @langchain/core @langchain/openai
npm install tavily @mendable/firecrawl-js resend zod
Environment variables (.env.local):
OPENAI_API_KEY=sk-...
TAVILY_API_KEY=tvly-...
FIRECRAWL_API_KEY=fc-...
RESEND_API_KEY=re_...
Step 2: Define Types
lib/types.ts:
import { BaseMessage } from '@langchain/core/messages'
export interface AgentState {
messages: BaseMessage[]
query: string
searchResults?: Array<{ title: string; url: string; content: string }>
reportContent?: string
analysis?: {
summary: string
keyMetrics: string[]
risks: string[]
opportunities: string[]
}
emailDraft?: {
subject: string
body: string
recipient: string
}
approved?: boolean
status: 'idle' | 'searching' | 'analyzing' | 'drafting' | 'awaiting_approval' | 'sending' | 'complete' | 'error'
error?: string
}
export interface ResearchResult {
query: string
results: Array<{
title: string
url: string
content: string
}>
}
Step 3: Build Research Service
lib/services/research.ts:
import { tavily } from '@tavily/core'
import FirecrawlApp from '@mendable/firecrawl-js'
const tavilyClient = tavily({ apiKey: process.env.TAVILY_API_KEY! })
const firecrawl = new FirecrawlApp({ apiKey: process.env.FIRECRAWL_API_KEY! })
export async function searchWeb(query: string) {
const response = await tavilyClient.search(query, {
search_depth: 'advanced',
max_results: 3
})
return response.results.map(r => ({
title: r.title,
url: r.url,
content: r.content
}))
}
export async function scrapePage(url: string): Promise<string> {
const result = await firecrawl.scrapeUrl(url, {
formats: ['markdown']
})
return result.markdown || ''
}
export async function researchTopic(query: string) {
// Search the web
const searchResults = await searchWeb(query)
// Scrape the top result
const content = await scrapePage(searchResults[0].url)
return {
query,
results: [{
...searchResults[0],
fullContent: content.slice(0, 5000) // Limit to 5000 chars
}]
}
}
Step 4: Build Email Service
lib/services/email.ts:
import { Resend } from 'resend'
const resend = new Resend(process.env.RESEND_API_KEY!)
export async function sendEmail(params: {
to: string
subject: string
html: string
}) {
const { data, error } = await resend.emails.send({
from: 'Agent <agent@yourdomain.com>',
to: params.to,
subject: params.subject,
html: params.html
})
if (error) {
throw new Error(`Failed to send email: ${error.message}`)
}
return data
}
Step 5: Create Agent Nodes
lib/agent/nodes.ts:
import { ChatOpenAI } from '@langchain/openai'
import { HumanMessage, AIMessage } from '@langchain/core/messages'
import { AgentState } from '@/lib/types'
import { researchTopic } from '@/lib/services/research'
const llm = new ChatOpenAI({ model: 'gpt-5' })
// Node 1: Research
export async function researchNode(state: AgentState): Promise<Partial<AgentState>> {
try {
const results = await researchTopic(state.query)
return {
searchResults: results.results,
reportContent: results.results[0].fullContent,
status: 'analyzing',
messages: [
...state.messages,
new AIMessage(`Found report: ${results.results[0].title}`)
]
}
} catch (error) {
return {
status: 'error',
error: error.message
}
}
}
// Node 2: Analyze
export async function analyzeNode(state: AgentState): Promise<Partial<AgentState>> {
const prompt = `Analyze this earnings report and extract:
1. A 2-sentence summary
2. Key financial metrics (3-5 bullets)
3. Top risks (3-5 bullets)
4. Opportunities (3-5 bullets)
Report:
${state.reportContent}
Return as JSON with keys: summary, keyMetrics, risks, opportunities`
const response = await llm.invoke([new HumanMessage(prompt)])
const analysis = JSON.parse(response.content as string)
return {
analysis,
status: 'drafting',
messages: [
...state.messages,
new AIMessage('Analysis complete')
]
}
}
// Node 3: Draft Email
export async function draftNode(state: AgentState): Promise<Partial<AgentState>> {
const prompt = `Write a professional business email summarizing this earnings analysis.
Include:
- Brief intro
- Summary
- Key metrics
- Risks
- Opportunities
- Brief conclusion
Analysis:
${JSON.stringify(state.analysis, null, 2)}
Format as a professional business email.`
const response = await llm.invoke([new HumanMessage(prompt)])
return {
emailDraft: {
subject: `${state.query.split(' ')[0]} Earnings Analysis`,
body: response.content as string,
recipient: 'placeholder@example.com' // Will be set by user
},
status: 'awaiting_approval',
messages: [
...state.messages,
new AIMessage('Draft ready for review')
]
}
}
// Node 4: Send Email
export async function sendNode(state: AgentState): Promise<Partial<AgentState>> {
if (!state.approved) {
return {
status: 'complete',
messages: [
...state.messages,
new AIMessage('Email sending cancelled')
]
}
}
// In production, this would call the email service
// For now, we'll simulate it
return {
status: 'complete',
messages: [
...state.messages,
new AIMessage(`Email sent to ${state.emailDraft!.recipient}`)
]
}
}
Step 6: Build the LangGraph Workflow
lib/agent/graph.ts:
import { StateGraph } from '@langchain/langgraph'
import { AgentState } from '@/lib/types'
import { researchNode, analyzeNode, draftNode, sendNode } from './nodes'
function routeNext(state: AgentState): string {
switch (state.status) {
case 'searching': return 'analyze'
case 'analyzing': return 'draft'
case 'drafting': return 'send'
case 'awaiting_approval': return 'send'
default: return '__end__'
}
}
export function createAgentGraph() {
const workflow = new StateGraph<AgentState>({
channels: {
messages: { value: (prev, next) => [...prev, ...next] },
query: { value: (prev, next) => next || prev },
searchResults: { value: (prev, next) => next || prev },
reportContent: { value: (prev, next) => next || prev },
analysis: { value: (prev, next) => next || prev },
emailDraft: { value: (prev, next) => next || prev },
approved: { value: (prev, next) => next ?? prev },
status: { value: (prev, next) => next || prev },
error: { value: (prev, next) => next || prev }
}
})
workflow.addNode('research', researchNode)
workflow.addNode('analyze', analyzeNode)
workflow.addNode('draft', draftNode)
workflow.addNode('send', sendNode)
workflow.setEntryPoint('research')
workflow.addConditionalEdges('research', routeNext)
workflow.addConditionalEdges('analyze', routeNext)
workflow.addConditionalEdges('draft', routeNext)
workflow.addEdge('send', '__end__')
return workflow.compile()
}
Step 7: API Route
app/api/agent/route.ts:
import { createAgentGraph } from '@/lib/agent/graph'
import { HumanMessage } from '@langchain/core/messages'
export async function POST(req: Request) {
const { query, approved, recipient } = await req.json()
const graph = createAgentGraph()
const initialState = {
messages: [new HumanMessage(query)],
query,
status: 'searching' as const,
approved,
emailDraft: recipient ? { recipient } : undefined
}
const result = await graph.invoke(initialState)
return Response.json(result)
}
Step 8: Frontend
app/page.tsx:
'use client'
import { useState } from 'react'
import { AgentState } from '@/lib/types'
export default function Page() {
const [query, setQuery] = useState('')
const [email, setEmail] = useState('')
const [state, setState] = useState<AgentState | null>(null)
const [loading, setLoading] = useState(false)
async function runAgent() {
setLoading(true)
const res = await fetch('/api/agent', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ query, recipient: email })
})
const result = await res.json()
setState(result)
setLoading(false)
}
async function approve() {
setLoading(true)
const res = await fetch('/api/agent', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
query: state!.query,
approved: true,
recipient: email
})
})
const result = await res.json()
setState(result)
setLoading(false)
}
return (
<div className="min-h-screen bg-gray-50 p-8">
<div className="max-w-4xl mx-auto">
<h1 className="text-4xl font-bold mb-8">Business Analyst Agent</h1>
{/* Input Form */}
<div className="bg-white rounded-lg shadow-lg p-6 mb-6">
<div className="mb-4">
<label className="block text-sm font-medium mb-2">Research Query</label>
<input
type="text"
value={query}
onChange={(e) => setQuery(e.target.value)}
placeholder="e.g., Tesla latest quarterly earnings report"
className="w-full p-3 border rounded-lg"
/>
</div>
<div className="mb-4">
<label className="block text-sm font-medium mb-2">Your Email</label>
<input
type="email"
value={email}
onChange={(e) => setEmail(e.target.value)}
placeholder="you@company.com"
className="w-full p-3 border rounded-lg"
/>
</div>
<button
onClick={runAgent}
disabled={loading || !query || !email}
className="w-full bg-blue-600 text-white py-3 rounded-lg font-semibold disabled:opacity-50"
>
{loading ? 'Processing...' : 'Start Research'}
</button>
</div>
{/* Status */}
{state && (
<div className="bg-white rounded-lg shadow-lg p-6">
<div className="mb-4">
<span className="text-sm font-medium text-gray-500">Status:</span>
<span className="ml-2 font-semibold">{state.status}</span>
</div>
{/* Analysis */}
{state.analysis && (
<div className="mb-6">
<h3 className="text-xl font-bold mb-3">Analysis</h3>
<p className="mb-4">{state.analysis.summary}</p>
<h4 className="font-semibold mb-2">Key Metrics:</h4>
<ul className="list-disc pl-5 mb-4">
{state.analysis.keyMetrics.map((m, i) => <li key={i}>{m}</li>)}
</ul>
<h4 className="font-semibold mb-2">Risks:</h4>
<ul className="list-disc pl-5 mb-4">
{state.analysis.risks.map((r, i) => <li key={i}>{r}</li>)}
</ul>
</div>
)}
{/* Email Draft */}
{state.emailDraft && state.status === 'awaiting_approval' && (
<div className="border-t pt-6">
<h3 className="text-xl font-bold mb-3">Email Draft</h3>
<div className="bg-gray-50 p-4 rounded mb-4">
<p className="font-semibold mb-2">Subject: {state.emailDraft.subject}</p>
<pre className="whitespace-pre-wrap text-sm">{state.emailDraft.body}</pre>
</div>
<div className="flex gap-4">
<button
onClick={approve}
className="flex-1 bg-green-600 text-white py-3 rounded-lg font-semibold"
>
Approve & Send
</button>
<button
onClick={() => setState(null)}
className="flex-1 bg-red-600 text-white py-3 rounded-lg font-semibold"
>
Cancel
</button>
</div>
</div>
)}
{/* Complete */}
{state.status === 'complete' && (
<div className="text-center py-8">
<div className="text-6xl mb-4">✅</div>
<h3 className="text-2xl font-bold">Email Sent!</h3>
</div>
)}
</div>
)}
</div>
</div>
)
}
Step 9: Deploy
vercel
Add your environment variables in the Vercel dashboard, and you're live!
Enhancement Ideas
1. Add RAG for company knowledge:
// Before searching the web, check internal docs
const internalDocs = await searchDocuments(query)
if (internalDocs.length > 0) {
// Use internal data instead
}
2. Schedule reports:
// Run the agent on a schedule (e.g., every Monday)
export async function GET() {
const companies = ['Apple', 'Tesla', 'Amazon']
for (const company of companies) {
await runAgent(`${company} latest earnings`)
}
return Response.json({ success: true })
}
3. Add chat interface:
// Let users refine the analysis through conversation
import { useChat } from '@ai-sdk/react'
import { DefaultChatTransport } from 'ai'
const { messages, sendMessage } = useChat({
transport: new DefaultChatTransport({ api: '/api/agent' })
})
Key Takeaways
You've built a production-ready autonomous agent that:
- ✅ Searches the web autonomously
- ✅ Extracts and analyzes information
- ✅ Drafts professional documents
- ✅ Requires human approval for sensitive actions
- ✅ Executes actions via APIs
- ✅ Has a beautiful UI
- ✅ Is deployed to production
This is the blueprint for building any autonomous agent.
What You've Accomplished
You can now:
- Build agents in JavaScript/TypeScript
- Implement tool calling for external capabilities
- Orchestrate complex workflows with LangGraph
- Add memory and RAG for knowledge retrieval
- Build production UIs with streaming and generative UI
- Deploy agents to Vercel
You are an AI engineer.
Next: The Epilogue – Where to go from here.
التالي · الدرس 8 من 8
The Road Ahead
قراءة 5 دقيقة
أنهيت 7 من 8 درسًا

اسأل Byte عن هذا الدرس
محادثة خاصة حول هذا الدرس. قرأ Byte الدرس كاملًا، ويجيب خلال ثوانٍ، ويُظهر القسم الذي تأتي منه كل إجابة. يمكنك السؤال بأي لغة.
الأسئلة والأجوبة
أسئلة عامة حول هذا الدرس. يجيب AI Tutor فورًا بلغتك، ويراجع فريق FreeAcademy الإجابات، ويمكن لكل المتعلمين قراءتها.

