Workflow

mkdir langbase-workflow
cd langbase-workflow

LANGBASE_API_KEY=<USER/ORG_API_KEY>
LLM_API_KEY=<LLM_API_KEY>

import 'dotenv/config';
import {Langbase, Workflow} from 'langbase';

async function processEmail({emailContent}: {emailContent: string}) {
	// Initialize Langbase
	const langbase = new Langbase({
		apiKey: process.env.LANGBASE_API_KEY!,
	});

	// Create a new workflow
	const workflow = new Workflow({
		debug: true,
	});

	try {
		// Steps 1 & 2: Run summary and sentiment analysis in parallel
		const [summary, sentiment] = await Promise.all([
			workflow.step({
				id: 'summarize_email', // The id for the step
				run: async () => {
					const response = await langbase.agent.run({
						model: 'openai:gpt-4.1-mini',
						instructions: `Create a concise summary of this email. Focus on the main points,
                                requests, and any action items mentioned.`,
						apiKey: process.env.OPENAI_API_KEY!,
						input: [{role: 'user', content: emailContent}],
						stream: false,
					});

					return response.output;
				},
			}),

			workflow.step({
				id: 'analyze_sentiment',
				run: async () => {
					const response = await langbase.agent.run({
						model: 'openai:gpt-4.1-mini',
						instructions: `Analyze the sentiment of this email. Provide a brief analysis
            that includes the overall tone (positive, neutral, or negative) and any notable
            emotional elements.`,
						apiKey: process.env.OPENAI_API_KEY!,
						input: [{role: 'user', content: emailContent}],
						stream: false,
					});

					return response.output;
				},
			}),
		]);

		// Step 3: Determine if response is needed (using the results from previous steps)
		const responseNeeded = await workflow.step({
			id: 'determine_response_needed',
			run: async () => {
				const response = await langbase.agent.run({
					model: 'openai:gpt-4.1-mini',
					instructions: `Based on the email summary and sentiment analysis, determine if a
          response is needed. Answer with 'yes' if a response is required, or 'no' if no
          response is needed. Consider factors like: Does the email contain a question?
          Is there an explicit request? Is it urgent?`,
					apiKey: process.env.OPENAI_API_KEY!,
					input: [
						{
							role: 'user',
							content: `Email: ${emailContent}\n\nSummary: ${summary}\n\nSentiment: ${sentiment}\n\nDoes this email
              require a response?`,
						},
					],
					stream: false,
				});

				return response.output.toLowerCase().includes('yes');
			},
		});

		// Step 4: Generate response if needed
		let response: string | null = null;
		if (responseNeeded) {
			response = await workflow.step({
				id: 'generate_response',
				run: async () => {
					const response = await langbase.agent.run({
						model: 'openai:gpt-4.1-mini',
						instructions: `Generate a professional email response. Address all questions
            and requests from the original email. Be helpful, clear, and maintain a
            professional tone that matches the original email sentiment.`,
						apiKey: process.env.OPENAI_API_KEY!,
						input: [
							{
								role: 'user',
								content: `Original Email: ${emailContent}\n\nSummary: ${summary}\n\n
                Sentiment Analysis: ${sentiment}\n\nPlease draft a response email.`,
							},
						],
						stream: false,
					});

					return response.output;
				},
			});
		}

		// Return the results
		return {
			summary,
			sentiment,
			responseNeeded,
			response,
		};
	} catch (error) {
		console.error('Email processing workflow failed:', error);
		throw error;
	}
}

async function main() {
	const sampleEmail = `
Subject: Pricing Information and Demo Request

    Hello,

    I came across your platform and I'm interested in learning more about your product
    for our growing company. Could you please send me some information on your pricing tiers?

    We're particularly interested in the enterprise tier as we now have a team of about
    50 people who would need access. Would it be possible to schedule a demo sometime next week?

    Thanks in advance for your help!

    Best regards,
    Jamie

`;

	const results = await processEmail({emailContent: sampleEmail});
	console.log(JSON.stringify(results, null, 2));
}

main();

npx tsx workflow.ts

{
  "summary": "The sender is interested in learning more about the product for their
  company of about 50 people. They are requesting pricing information, particularly for
  the enterprise tier, and would like to schedule a demo next week.",
  "sentiment": "positive",
  "responseNeeded": true,
  "response": "Subject: RE: Pricing Information and Demo Request

  Hello Jamie,

  Thank you for your interest in our platform! I'd be happy to provide you with
  information about our pricing tiers and arrange a demo for your team.

  For an enterprise-level organization with 50 users, our Enterprise tier would indeed
  be the most suitable option. This package includes:

  - Unlimited access for all team members
  - Advanced security features
  - Dedicated account manager
  - Custom integrations
  - Priority support

  I've attached our complete pricing brochure with detailed information about all our
  plans. For your team size, we offer custom pricing with volume discounts.

  Regarding the demo, I'd be delighted to schedule one for next week. Could you please
  let me know what days and times work best for you and your team? Our demos typically
  take about 45 minutes and include time for questions.

  If you have any specific features or use cases you'd like us to focus on during the demo,
  please let me know so I can tailor the presentation to your needs.

  Looking forward to hearing from you and showing you how our platform can benefit your
  growing company.

  Best regards,

  [Your Name]
  [Your Position]
  [Contact Information]"
}