It can connect to messaging interfaces, local tools, and model providers while keeping execution and data closer to your own infrastructure.

The project is actively developed, and the current ecosystem revolves around a CLI-driven setup flow, onboarding wizard, and multiple deployment paths ranging from local installs to containerised or cloud-hosted setups.

This article explains how to deploy your own instance of OpenClaw from a practical systems perspective. We'll look at how to deploy it on your local machine as well as a PaaS provider like Sevalla.

The goal is not just to “make it run,” but to understand deployment choices, architecture implications, and operational tradeoffs so you can run a stable instance long term.

Note: It is dangerous to give an AI system full control of your system. Make sure you understand the risks before running it on your machine.

What we'll cover:

1. Understanding What You Are Deploying

2. Deploying on a Local Machine

3. Deploying on the Cloud using Sevalla

4. Interacting with the Agent

5. Security and Operational Considerations

6. Updating and Maintaining Your Instance

7. Conclusion

Understanding What You Are Deploying

Before touching installation commands, it helps to understand the runtime model.

OpenClaw is essentially a local-first AI assistant that runs as a service and exposes interaction through chat interfaces and a gateway architecture.

The gateway acts as the operational core, handling communication between messaging platforms, models, and local capabilities.

In practical terms, deploying OpenClaw means deploying three layers.

The first layer is the CLI and runtime, which launches and manages the assistant.

The second layer is configuration and onboarding, where you select model providers and integrations.

The third layer is persistence and execution context, which determines whether OpenClaw runs on your laptop, a VPS, or inside a container.

Because OpenClaw runs with access to local resources, deployment decisions are not only about convenience but also about security boundaries. Treat it as an administrative system, not just a chatbot.

Deploying on a Local Machine

OpenClaw supports multiple deployment approaches, and the right one depends on your goals.

The simplest route is to install it directly on a local machine. This is ideal for experimentation, private workflows, or development because onboarding is fast and maintenance is minimal.

The installer script handles environment detection, dependency setup, and launching the onboarding wizard.

The fastest way to install OpenClaw is via the official installer script. The installer downloads the CLI, installs it globally through npm, and launches onboarding automatically.

curl -fsSL https://openclaw.ai/install.cmd -o install.cmd && install.cmd && del install.cmd

This method abstracts away most environmental complexity and is recommended for first-time deployments.

If you already maintain a Node environment, you can install it directly using npm.

npm i -g openclaw

The CLI is then used to run onboarding and optionally install a daemon for persistent background execution. This approach gives you more control over versioning and update cadence.

openclaw onboard

Regardless of installation path, verify that the CLI is discoverable in your shell. Environment path issues are common when global npm packages are installed under custom Node managers.

The Onboarding Process

Once installed, OpenClaw relies heavily on onboarding to bootstrap configuration.

During onboarding you will select an AI provider, configure authentication, and choose how you want to interact with the assistant. This process establishes the core runtime state and generates local configuration files used by the gateway.

Onboarding also allows you to connect messaging channels such as Telegram or Discord. These integrations transform OpenClaw from a local CLI tool into an always-accessible assistant.

From a deployment perspective, this is the moment where availability requirements change. If you connect external chat platforms, your instance must remain online consistently.

You can skip certain onboarding steps and configure integrations later, but for production deployments it's better to complete the initial configuration so you can validate end-to-end functionality immediately.

Once you add an OpenAI API key or Claude key, you can choose to open the web UI.

Go to localhost:18789 to interact with OpenClaw.

Deploying on the Cloud using Sevalla

A second approach is to deploy to a VPS or cloud instance. This model gives you always-on availability and makes it possible to interact with OpenClaw from anywhere.

A third approach is containerised deployment using Docker or similar tooling. This provides reproducibility and cleaner dependency isolation.

Docker setups are particularly useful if you want predictable upgrades or easy migration between machines. OpenClaw’s repository includes scripts and compose configurations that support container execution workflows.

I have set up a custom Docker image to load OpenClaw into a PaaS platform like Sevalla.

Sevalla is a developer-friendly PaaS provider. It offers application hosting, database, object storage, and static site hosting for your projects.

Log in to Sevalla and click “Create application”. Choose “Docker image” as the application source instead of a GitHub repository. Use manishmshiva/openclaw as the Docker image, and it will be pulled automatically from DockerHub.

Click “Create application” and go to the environment variables. Add an environment variable ANTHROPIC_API_KEY . Then go to “Deployments” and click “Deploy now”.

Once the deployment is successful, you can click “Visit app” and interact with the UI with the Sevalla-provided URL.

Interacting with the Agent

There are many ways to interact with the agent once you set up Openclaw. You can configure a Telegram bot to interact with your agent. Basically, the agent will (try to) do a task similar to a human assistant. Its capabilities depend on how much access you provide the agent.

You can ask it to clean your inbox, watch a website for new articles, and perform many other tasks. Please note that providing OpenClaw access to your critical apps or files is not ideal or secure. This is still a system in its early stages, and the risk of it making a mistake or exposing your private information is high.

Here are some of the ways people are using OpenClaw.

Security and Operational Considerations

Because OpenClaw can execute tasks and access system resources, deployment security is not optional. The safest baseline is to bind services to localhost and access them through secure VPN tunnels when remote control is required. Learn more about VPNs here.

When deploying on a VPS, harden the host like any administrative service. Use non-root users, keep packages updated, restrict inbound ports, and monitor logs. If you're integrating messaging channels, treat tokens and API keys as sensitive secrets and avoid storing them in plaintext configuration where possible.

Containerization helps isolate dependencies but doesn't eliminate risk. The container still executes code on your host, so network and volume permissions should be carefully scoped.

Updating and Maintaining Your Instance

OpenClaw evolves quickly, with frequent releases and feature changes. Keeping your instance updated is important not only for features but also for stability and compatibility with integrations.

For npm-based installations, updates are straightforward, but you should test upgrades in a staging environment if your assistant handles important workflows. For source-based deployments, pull changes and rebuild consistently rather than mixing old build artifacts with new code.

Monitoring is another overlooked aspect. Even simple log inspection can reveal integration failures early. If your deployment is mission-critical, consider external uptime checks or process supervisors.

Conclusion

Deploying your own OpenClaw agent is ultimately about taking control of how your AI assistant works, where it runs, and how it fits into your daily workflows. While the setup process is straightforward, the real value comes from understanding the choices you make along the way, whether you run it locally for privacy, host it in the cloud for constant availability, or use containers for consistency and portability.

As the ecosystem around self-hosted AI continues to evolve, tools like OpenClaw make it possible to move beyond relying entirely on third-party platforms. Running your own agent gives you flexibility, ownership, and the freedom to shape the experience around your needs.

Start small, experiment safely, and gradually build confidence in how your assistant operates. Over time, what begins as a simple deployment can become a dependable, personalized system that works the way you want , under your control.

Hope you enjoyed this article. Learn more about me by visiting my website.

Application logs, server logs, and infrastructure logs often contain the first clues when something breaks. The problem is not a lack of data, but the effort required to read and understand it.

Engineers usually scroll through thousands of lines, search for error codes, and try to connect events across time. This is slow and error-prone, especially during incidents.

A LogAnalyzer Agent solves this problem by acting like a calm, experienced engineer who reads logs for you and explains what is going on.

In this article, you’ll learn how to build such an agent using FastAPI, LangChain, and an OpenAI model.

We’ll walk through the backend, the log analysis logic, and a simple web UI that lets you upload a log file and get insights in seconds. We’ll also upload this app to Sevalla so that you can share your project with the world.

You just need some basic knowledge of Python and HTML/CSS/JavaScript to finish this tutorial.

Here is the full code for reference.

What We’ll Cover

• What a LogAnalyzer Agent Actually Does

• High-Level Architecture

• Designing a Prompt That Works

• Handling Large Log Files Safely

• Analyzing Logs with LangChain and OpenAI

• Building the FastAPI Backend

• Creating a Simple and Clean Web UI

• Running the Application Locally

• Deployment to Sevalla

• Conclusion

What a LogAnalyzer Agent Actually Does

A LogAnalyzer Agent takes raw log text as input and produces human-friendly analysis as output.

Instead of returning a list of errors, it explains the main failures, the likely root cause, and what to do next. This is important because logs are written for machines, not for people under pressure.

In this project, the agent behaves like a senior site reliability engineer. It reads logs in chunks, identifies patterns, and summarises them in simple language. The intelligence comes from a language model, while the reliability comes from careful handling of input and chunking.

High-Level Architecture

The system has three main parts.

The first part is a web UI built with plain HTML, CSS, and JavaScript. This UI allows a user to upload a text file and start analysis.

The second part is a FastAPI backend that receives the file, validates it, and coordinates the analysis.

The third part is the analysis engine itself, which uses LangChain and an OpenAI model to interpret the logs.

The flow is simple: the browser sends a log file to the backend. The backend reads the file, splits it into manageable pieces, and sends each piece to the language model with a clear prompt. The responses are combined and sent back to the browser as a single analysis.

Designing a Prompt That Works

The heart of any AI agent is the prompt. A weak prompt gives vague answers, while a strong prompt produces useful insights.

In this project, the prompt tells the model to act like a senior site reliability engineer. It asks for four things: main errors, likely root cause, practical next steps, and suspicious patterns.

Here is the prompt template used in the backend:

log_analysis_prompt_text = """
You are a senior site reliability engineer.
Analyze the following application logs.
1. Identify the main errors or failures.
2. Explain the likely root cause in simple terms.
3. Suggest practical next steps to fix or investigate.
4. Mention any suspicious patterns or repeated issues.
Logs:
{log_data}
Respond in clear paragraphs. Avoid jargon where possible.
"""

This prompt is simple but effective. It gives the model a role, a clear task, and constraints on the output style. Asking for clear paragraphs helps ensure the response is readable and useful for non-experts as well.

Handling Large Log Files Safely

Language models have input limits. You can’t send a large log file in one request and expect good results. To handle this, the backend splits the log text into smaller chunks. Each chunk overlaps slightly with the next to preserve context.

We’ll use the RecursiveCharacterTextSplitter from LangChain for this purpose. It ensures that chunks aren’t cut in awkward places and that important lines aren’t lost.

def split_logs(log_text: str):
    """Split log text into manageable chunks"""
    splitter = RecursiveCharacterTextSplitter(
        chunk_size=2000,
        chunk_overlap=200
    )
    return splitter.split_text(log_text)

This approach allows the agent to scale to large files while staying within model limits. Each chunk is analyzed independently, and the results are later combined.

Analyzing Logs with LangChain and OpenAI

Once the logs are split, each chunk is passed through the language model using the prompt template. The model used here is a lightweight but capable option, configured with a low temperature to keep responses focused and consistent.

llm = ChatOpenAI(
    temperature=0.2,
    model="gpt-4o-mini"
)

The analysis function loops over all chunks, formats the prompt, invokes the model, and stores the result.

def analyze_logs(log_text: str):
    """Analyze logs by splitting and processing each chunk"""
    chunks = split_logs(log_text)
    combined_analysis = []

  for chunk in chunks:
          formatted_prompt = log_analysis_prompt_text.format(log_data=chunk)
          result = llm.invoke(formatted_prompt)
          combined_analysis.append(result.content)
      return "\n\n".join(combined_analysis)

This design keeps the logic easy to understand. Each chunk produces a small analysis, and the final output is a stitched together explanation of the whole log file.

Building the FastAPI Backend

FastAPI is a good choice for this project because it’s fast, simple, and easy to read. The backend exposes three endpoints. The root endpoint serves the HTML UI. The /analyze endpoint accepts a log file and returns the analysis. And the /health endpoint is used to check if the service is running and properly configured.

The analyze endpoint performs several important checks. It ensures that the file is a text file, verifies that it isn’t empty, and handles errors gracefully. This prevents unnecessary calls to the model and improves user experience.

@app.post("/analyze")
async def analyze_log_file(file: UploadFile = File(...)):
    """Analyze uploaded log file"""
    if not file.filename.endswith(".txt"):
        return JSONResponse(
            status_code=400,
            content={"error": "Only .txt log files are supported"}
        )

     try:
        content = await file.read()
        log_text = content.decode("utf-8", errors="ignore")
        if not log_text.strip():
            return JSONResponse(
                status_code=400,
                content={"error": "Log file is empty"}
            )
        insights = analyze_logs(log_text)
        return {"analysis": insights}
    except Exception as e:
        return JSONResponse(
            status_code=500,
            content={"error": f"Error analyzing logs: {str(e)}"}
        )

This careful handling makes the agent more robust and production-friendly.

Creating a Simple and Clean Web UI

A good agent isn’t useful if people can’t interact with it easily. The frontend in this project is a single HTML file with embedded CSS and JavaScript. It focuses on clarity and speed rather than complexity.

The UI allows users to choose a log file, see the file name, click an analyze button, and view results in a formatted area. A loading spinner provides feedback while the analysis is running. Errors are shown clearly, without technical noise.

The upload and analysis logic is handled by a small JavaScript function that sends the file to the backend using a fetch request.

async function uploadLog() {
    const fileInput = document.getElementById("logFile");
    const file = fileInput.files[0];

if (!file) {
        alert("Please select a log file first");
        return;
    }
    const formData = new FormData();
    formData.append("file", file);
    const response = await fetch("/analyze", {
        method: "POST",
        body: formData
    });
    const data = await response.json();
    document.getElementById("result").textContent = data.analysis;
}

This minimal approach keeps the frontend easy to maintain and adapt.

Running the Application Locally

To run this project, you need Python, a virtual environment, and an OpenAI API key. The API key is loaded from a .env file to keep secrets out of code. Once dependencies are installed, you can start the server using Uvicorn.

if __name__ == "__main__":
    import uvicorn
    port = int(os.getenv("PORT", 8000))
    uvicorn.run(app, host="0.0.0.0", port=port)

After starting the server, you can open the browser, upload a log file, and see the agent in action.

Deployment to Sevalla

You can choose any cloud provider, like AWS, DigitalOcean, or others, to host your service. I’ll be using Sevalla for this example.

Sevalla is a developer-friendly PaaS provider. It offers application hosting, database, object storage, and static site hosting for your projects.

Every platform will charge you for creating a cloud resource. Sevalla comes with a $20 credit for us to use, so we won’t incur any costs for this example.

Let’s push this project to GitHub so that we can connect our repository to Sevalla. We can also enable auto-deployments so that any new change to the repository is automatically deployed.

Log in to Sevalla and click on Applications → Create new application.

You can see the option to link your GitHub repository to create a new application. Use the default settings. Then click Create application.

Now we have to add our OpenAI API key to the environment variables. Click on the Environment variables section once the application is created, and save the OPENAI_API_KEY value as an environment variable.

Now we’re ready to deploy our application. Click on Deployments and click Deploy now. It will take 2–3 minutes for the deployment to complete.

Once done, click on Visit app. You’ll see the application served via a URL ending with sevalla.app. This is your new root URL. You can replace localhost:8000 with this URL and start using it.

Congrats! Your log analyzer service is now live. You can find a sample log in the GitHub repository which you can use to test the service.

You can extend this by adding other capabilities and pushing your code to GitHub. Sevalla will automatically deploy your application to production.

Conclusion

Building a LogAnalyzer Agent is a practical way to apply language models to real engineering problems. Logs are everywhere, and understanding them quickly can save hours during incidents. By combining FastAPI, LangChain, and a clear prompt, you can turn raw text into actionable insight.

The key ideas are simple: split large inputs, guide the model with a strong role and task, and present results in a clean interface. With these principles, you can adapt this agent to many other analysis tasks beyond logs.

Hope you enjoyed this article. Learn more about me by visiting my website.

You can build powerful agentic systems without heavyweight frameworks or orchestration engines. One of the simplest and most effective ways to do that is to use Langbase agentic architectures (built with AI primitives that don't require a framework to ship scalable AI agentic systems).

In this article, we’ll dive into one of Langbase's agentic architectures: prompt chaining. We’ll look at why it’s useful and how to implement it by building a prompt chaining agent.

Table of Contents

1. Prerequisites

2. AI primitives (agentic architecture)

3. What is prompt chaining?

4. Prompt chaining architecture

5. Langbase SDK

6. Building a prompt chaining agent using Langbase Pipes

   • Step 1: Setup your project

   • Step 2: Get Langbase API Key

   • Step 3: Add LLM API keys

   • Step 4: Add logic in prompt-chaining.ts file

   • Step 5: Run the file

7. The result

Prerequisites

Before we begin creating a prompt chaining agent, you’ll need to have the following setup and tools ready to go.

In this tutorial, I’ll be using the following tech stack:

• Langbase – the platform to build and deploy your serverless AI agents.

• Langbase SDK – a TypeScript AI SDK, designed to work with JavaScript, TypeScript, Node.js, Next.js, React, and the like.

• OpenAI – to get the LLM key for the preferred model.

You’ll also need to:

• Sign up on Langbase to get access to the API key.

• Sign up on OpenAI to generate the LLM key for the model you want to use (for this demo, I’ll be using the openai:gpt-4o-mini model). You can generate the key here.

AI Primitives (Agentic Architecture)

An AI primitive level approach means building AI systems using the most basic building blocks – without relying on heavy abstractions, orchestration engines, or full-blown frameworks.

Langbase Pipe and Memory agents serve as these building blocks.

Pipe agents on Langbase are different from other agents. They are serverless AI agents with agentic tools that can work with any language or framework. Pipe agents are easily deployable, and with just one API they let you connect 250+ LLMs to any data to build any developer API workflow.

Langbase memory agents (long-term memory solution) are designed to acquire, process, retain, and retrieve information seamlessly. They dynamically attach private data to any LLM, enabling context-aware responses in real time and reducing hallucinations. Memory, when connected to a pipe agent, becomes a memory agent.

With these building blocks (AI primitives) you can build entire agentic workflows. For this, Langbase agentic architectures serves as a boilerplate in building, deploying, and scaling autonomous agents.

Let’s look at one of the agentic architectures: prompt chaining.

What is Prompt Chaining?

Prompt chaining is an agent architecture where a task is broken down into a sequence of prompts. Each step passes its output to the next, enabling the LLM to handle more complex workflows with higher accuracy.

This is particularly useful for structured tasks like:

• Document summarization and analysis

• Multi-step content generation

• Data transformation and cleanup

• Content validation and refinement

Rather than relying on a single prompt to do everything, you split the work into focused steps. This makes it easier to debug, improves output quality, and introduces natural "checkpoints" in your AI workflow.

Prompt Chaining Architecture

Here’s a reference architecture explaining the workflow:

This diagram is a visual reference for how prompt chaining can be used to build a lightweight agentic system using just LLM calls and conditional logic – without any heavyweight frameworks.

Here’s a breakdown of what’s happening in the flow:

1. In → LLM Call

• Takes the initial input and runs the first LLM call.

• Produces Output 1.

2. Gate

• Evaluates Output 1 to decide the next step.

• Acts as a conditional checkpoint (for example, success/failure, intent validation, confidence threshold).

3. If Gate passes:

• Proceeds to LLM Call 2 with Output 1 as input.

• LLM Call 2 produces Output 2.

• Output 2 goes into LLM Call 3, which generates the final result.

• Final output flows into the Out.

4. If Gate fails:

• The flow terminates early at Exit.

• Skips further LLM calls, saving compute and avoiding invalid outputs.

Langbase SDK

The Langbase SDK makes it easy to build powerful AI agents using TypeScript. It gives you everything you need to work with any LLM, connect your own embedding models, manage document memory, and build AI agents that can reason and respond.

The SDK is designed to work with Node.js, Next.js, React, or any modern JavaScript stack. You can use it to upload documents, create semantic memory, and run AI workflows (called Pipes agents) with just a few lines of code.

Langbase is an API-first AI platform, and its TypeScript SDK smooths out the experience – making it easy to get started without dealing with infrastructure. Just drop in your API key, write your logic, and you're good to go.

Now that you know about Langbase SDK, let’s start building the prompt chaining agent.

Building a Prompt Chaining Agent using Langbase Pipes

Let’s walk through a real prompt chaining agentic system built using Langbase Pipe agents (serverless AI agents with unified APIs for every LLM). For this, we’ll be setting up a basic Node.js project.

We’ll be implementing a sequential product marketing content pipeline that transforms a raw product description into polished marketing copy through three stages (that is, the creation of three Pipe agents):

First Stage (Summary Agent):

• Takes a raw product description

• Condenses it into two concise sentences

• Has a quality gate that checks if the summary is detailed enough (at least 10 words)

Second Stage (Features Agent):

• Takes the summary from stage 1

• Extracts and formats key product features as bullet points

Final Stage (Marketing Copy Agent):

• Takes the bullet points from stage 2

• Generates refined marketing copy for the product

All stages will be using the OpenAI 4o-mini model through the Langbase SDK. The best part is that you can use different LLM models for each stage/Pipe agent creation as well.

What makes this interesting is its pipeline approach. Each stage builds upon the output of the previous stage, with a quality check after the summary stage to ensure the pipeline maintains high standards.

Let’s begin with the creation of this prompt chaining agentic system.

Step 1: Setup Your Project

I’ll be building a basic Node.js app in TypeScript that uses the Langbase SDK to create a scalable prompt chaining agentic system. It will work without any framework, following an AI primitive level approach.

To get started with that, create a new directory for your project and navigate to it:

mkdir agentic-architecture && cd agentic-architecture

Then initialize a Node.js project and create a TypeScript file by running this command in your terminal:

npm init -y && touch prompt-chaining.ts

The prompt-chaining.ts file will contain code of all the agent creations in it.

After this, we will be using the Langbase SDK to create the agents and dotenv to manage environment variables. So, let's install these dependencies.

npm i langbase dotenv

Step 2: Get Langbase API Key

Every request you send to Langbase needs an API key. You can generate API keys from the Langbase studio by following these steps:

1. Switch to your user or org account.

2. From the sidebar, click on the Settings menu.

3. In the developer settings section, click on the Langbase API keys link.

4. From here you can create a new API key or manage existing ones.

For more details, you can visit the Langbase API keys documentation.

After generating the API key, create an .env file in the root of your project and add your Langbase API key in it:

LANGBASE_API_KEY=xxxxxxxxx

Replace xxxxxxxxx with your Langbase API key.

Step 3: Add LLM API keys

Once you have the Langbase API key, you’ll be needing the LLM key as well to run the RAG agent. If you have set up LLM API keys in your profile, the AI memory and agent pipe will automatically use them. Otherwise navigate to the LLM API keys page and add keys for different providers like OpenAI, Anthropic, and so on.

Follow these steps to add the LLM keys:

1. Add LLM API keys in your account using Langbase studio

2. Switch to your user or org account.

3. From the sidebar, click on the Settings menu.

4. In the developer settings section, click on the LLM API keys link.

5. From here you can add LLM API keys for different providers like OpenAI, TogetherAI, Anthropic, and so on.

Step 4: Add logic in prompt-chaining.ts file

In the prompt-chaining.ts file you created in Step 1, add the following code:

import dotenv from 'dotenv';
import { Langbase } from 'langbase';


dotenv.config();


const langbase = new Langbase({
   apiKey: process.env.LANGBASE_API_KEY!
});


async function main(inputText: string) {
   // Prompt chaining steps
   const steps = [
       {
           name: `summary-agent-${Date.now()}`,
           model: 'openai:gpt-4o-mini',
           description:
               'summarize the product description into two concise sentences',
           prompt: `Please summarize the following product description into two concise
           sentences:\n`
       },
       {
           name: `features-agent-${Date.now()}`,
           model: 'openai:gpt-4o-mini',
           description: 'extract key product features as bullet points',
           prompt: `Based on the following summary, list the key product features as
           bullet points:\n`
       },
       {
           name: `marketing-copy-agent-${Date.now()}`,
           model: 'openai:gpt-4o-mini',
           description:
               'generate a polished marketing copy using the bullet points',
           prompt: `Using the following bullet points of product features, generate a
           compelling and refined marketing copy for the product, be precise:\n`
       }
   ];


   //  Create the pipe agents
   await Promise.all(
       steps.map(step =>
           langbase.pipes.create({
               name: step.name,
               model: step.model,
               messages: [
                   {
                       role: 'system',
                       content: `You are a helpful assistant that can ${step.description}.`
                   }
               ]
           })
       )
   );


   // Initialize the data with the raw input.
   let data = inputText;


   try {
       // Process each step in the workflow sequentially.
       for (const step of steps) {
           // Call the LLM for the current step.
           const response = await langbase.pipes.run({
               stream: false,
               name: step.name,
               messages: [{ role: 'user', content: `${step.prompt} ${data}` }]
           });


           data = response.completion;


           console.log(`Step: ${step.name} \n\n Response: ${data}`);


           // Gate on summary agent output to ensure it is not too brief.
           // If summary is less than 10 words, throw an error to stop the workflow.
           if (step.name === 'summary-agent' && data.split(' ').length < 10) {
               throw new Error(
                   'Gate triggered for summary agent. Summary is too brief. Exiting workflow.'
               );
               return;
           }
       }
   } catch (error) {
       console.error('Error in main workflow:', error);
   }


   // The final refined marketing copy
   console.log('Final Refined Product Marketing Copy:', data);
}


const inputText = `Our new smartwatch is a versatile device featuring a high-resolution display,
long-lasting battery life,fitness tracking, and smartphone connectivity. It's designed for
everyday use and is water-resistant. With cutting-edge sensors and a sleek design, it's
perfect for tech-savvy individuals.`;


main(inputText);

Here’s a breakdown of the above code:

Setup and initialization:

• dotenv loads env variables from the .env file for secure API key access.

• Langbase is imported from the SDK to interact with the API.

• A Langbase client instance is created using your API key.

Define the AI steps (prompt chain):

• Three AI agents (steps) are defined for a pipeline:

  1. Summarization Agent: Summarizes the input product description into 2 sentences.

  2. Feature Extraction Agent: Extracts key features from the summary as bullet points.

  3. Marketing Copy Agent: Turns bullet points into polished marketing copy.

• Each agent uses openai:gpt-4o-mini as the LLM.

Create Langbase Pipes (agents):

• Langbase pipes are created for each step using langbase.pipes.create(...).

• Each pipe has a unique name (timestamped) and a system message guiding its purpose.

Run the workflow (sequential processing):

• Input text flows through each step one by one:

  • The output of one step becomes the input for the next.

  • Pipes are run using langbase.pipes.run(...).

• Intermediate outputs are logged after each step.

Validation check (gatekeeping):

• If the summary output is too short (less than 10 words), the workflow stops with an error.

Final Output:

• After all steps, the final result is a refined marketing copy printed to the console.

For this article, we’re using a demo smartwatch product description to view the result in the inputText field.

Step 5: Run the file

To run the prompt-chaining.ts file to view the results, you need to:

• Add TypeScript as a dependency

• Add a script to run TypeScript files

• Add a TypeScript configuration file

For it lets first install pnpm by running this command in your terminal:

pnpm install

Then in your terminal again, run this command to add relevant dependencies and configuration files:

pnpm add -D typescript ts-node @types/node

After that, create a TypeScript configuration file tsconfig.json:

pnpm exec tsc --init

And update the package.json to add the relevant script. This is what your package.json should look like after updating:

{
 "name": "agentic-architectures",
 "version": "1.0.0",
 "main": "index.js",
 "scripts": {
   "test": "echo \"Error: no test specified\" && exit 1",
   "prompt-chaining": "ts-node prompt-chaining.ts"
 },
 "keywords": [],
 "author": "",
 "license": "ISC",
 "description": "",
 "dependencies": {
   "dotenv": "^16.5.0",
   "langbase": "^1.1.55"
 },
 "devDependencies": {
   "@types/node": "^22.14.1",
   "ts-node": "^10.9.2",
   "typescript": "^5.8.3"
 }
}

Now let’s run the project by pnpm run prompt-chaining

The Result

After running the project, you’ll see the result of the example smartwatch product description in your console as follows:

Step: summarize-description
Response: This smartwatch combines fitness tracking and smartphone connectivity with a high-resolution display and long-lasting battery. Designed for everyday use with a sleek, water-resistant build, it's ideal for tech enthusiasts.

Step: extract-features
Response: Okay, here are the key product features extracted from the summary:

Fitness Tracking
Smartphone Connectivity
High-Resolution Display
Long-Lasting Battery
Sleek Design
Water-Resistant Build
Designed for Everyday Use
Step: refine-marketing-copy
Response: ## Elevate Your Everyday with Seamless Connectivity and Unrivaled Performance.

Experience the perfect fusion of style and functionality with our revolutionary device, designed to seamlessly integrate into your active lifestyle. Stay motivated and informed with comprehensive Fitness Tracking, while effortlessly staying connected via Smartphone Connectivity.

Immerse yourself in vibrant clarity with the stunning High-Resolution Display, and power through your day without interruption thanks to the Long-Lasting Battery. Encased in a Sleek Design, this device is as stylish as it is practical.

Built to withstand the rigors of daily life, the Water-Resistant Build ensures worry-free wear, rain or shine. Engineered for comfort and performance, this device is Designed for Everyday Use, empowering you to live your best life, effortlessly.

This is how you can build a prompt chaining agentic system with AI primitives (no framework) using the Langbase SDK and Langbase agentic architectures.

Thank you for reading!

Connect with me by 🙌:

• Subscribing to my YouTube Channel. If you are willing to learn about AI and agents.

• Subscribing to my free newsletter “The Agentic Engineer” where I share all the latest AI and agents news/trends/jobs and much more.

• Follow me on X (Twitter).

This guide will walk you through building a cold email generator agent using serverless memory agents by Langbase to automate this entire process. We’ll integrate the memory agent into a Node.js project, enabling it to read your résumé, analyze the job description, and generate a personalized, high-impact cold email in seconds.

Here’s what I’ll cover:

1. Large language models (LLMs) are stateless by nature

2. What are Memory agents?

3. Prerequisites

4. Reference Architecture

5. Step 1: Create a directory and initialize npm

6. Step 2: Create a serverless Pipe agent

7. Step 3: Add a .env file

8. Step 4: Create a serverless memory agent

9. Step 5: Add documents to the memory agent

10. Step 6: Generate memory embeddings

    • Understanding memory embeddings

    • How to generate embeddings?

11. Step 7: Integrate memory in Pipe agent

12. Step 8: Integrate the memory agent in Node.js

13. Step 9: Start the BaseAI server

14. Step 10: Run the memory agent

15. The result

Large Language Models (LLMs) Are Stateless by Nature

LLMs (Large Language Models) are stateless because they don’t retain any memory of previous interactions or the context of past queries beyond the input they're given in a session. Each time an LLM processes a prompt, it operates on that specific prompt without any history from prior ones.

This stateless nature allows the model to treat each request as independent, which simplifies its architecture and training process. But this also means that without mechanisms like RAG (Retrieval-Augmented Generation) or memory (long-term), LLMs can't carry forward information from one interaction to the next.

To introduce continuity or context, developers can implement external systems to manage and inject context, but the model itself doesn't "remember" anything between requests.

How do we solve this?

By integrating Memory Agents by Langbase, we can give LLMs long-term memory—allowing them to store, retrieve, and use information dynamically, making them much more useful for real-world applications.

What Are Memory Agents?

Langbase serverless memory agents (long-term memory solution) are designed to acquire, process, retain, and retrieve information seamlessly. They dynamically attach private data to any LLM, enabling context-aware responses in real time and reducing hallucinations.

These agents combine vector storage, Retrieval-Augmented Generation (RAG), and internet access to create a powerful managed context search API. Developers can use them to build smarter, more capable AI applications.

In a RAG setup, memory – when connected directly to a Langbase Pipe Agent – becomes a memory agent. This pairing gives the LLM the ability to fetch relevant data and deliver precise, contextually accurate answers—addressing the limitations of LLMs when it comes to handling private data.

Memory agents ensure secure local memory storage. Data used to create memory embeddings stays protected, processed within secure environments, and only sent externally if explicitly configured. Access is strictly controlled via API keys, ensuring sensitive information remains safe.

Note that pipe is a serverless AI agent. It has agentic memory and tools.

Prerequisites

Before we begin creating a cold email generator agent, you’ll need to have the following setup and tools ready to go.

In this tutorial, I’ll be using this tech stack:

• BaseAI — the web framework for building AI agents locally.

• Langbase — the platform to build and deploy your serverless AI agents.

• OpenAI — to get the LLM key for the preferred model.

You’ll also need to:

• Sign up on Langbase to get access to the API key.

• Sign up on OpenAI to generate the LLM key for the model you want to use (for this demo, I’ll be using GPT-4o mini). You can generate the key here.

Reference Architecture

Here’s a diagrammatic representation of the entire process of building a serverless AI agent to generate cold emails for job applications:

Let’s start building the agent!

Step 1: Create a Directory and Initialize npm

To start creating a serverless AI agent that generates cold emails for a job opening, you need to create a directory in your local machine and install all the relevant dev dependencies in it. You can do this by navigating to it and running the following command in the terminal:

mkdir my-project
npm init -y
npm install dotenv

This command will create a package.json file in your project directory with default values. It will also install the dotenv package to read environment variables from the .env file.

Step 2: Create a Serverless Pipe Agent

Next, we’ll be creating a pipe agent. Pipes are different from other agents, as they are serverless AI agents with agentic tools that can work with any language or framework. They are easily deployable, and with just one API they let you connect more than 250 LLMs to any data to build any developer API workflow.

To create your AI agent pipe, navigate to your project directory. Run the following command:

npx baseai@latest pipe

Upon running, you’ll see the following prompts:

BaseAI is not installed but required to run. Would you like to install it? Yes/No
Name of the pipe? email-generator-agent
Description of the pipe? Generates emails for your dream job in seconds
Status of the pipe? Public/Private
System prompt? You are a helpful AI assistant

Once you are done with the name, description, and status of the AI agent pipe, everything will be set up automatically for you. Your pipe will be created successfully at /baseai/pipes/email-generator-agent.ts.

Step 3: Add a .env File

Create a .env file in the root directory of your project and add the OpenAI and Langbase API keys in it. You can access your Langbase API key from here.

Step 4: Create a Serverless Memory Agent

Next, we’ll be creating a memory and then attaching it with the Pipe to make it a memory agent. To do this, run this command in your terminal:

npx baseai@latest memory

Upon running this command, you’ll see the following prompts:

Name of the memory? email-generator-memory
Description of the memory? Contains my resume
Do you want to create memory from the current project git repository? Yes/No

After this, everything will be set up automatically for you and you can access your memory created successfully at /baseai/memory/email-generator-memory.ts.

Step 5: Add Documents to the Memory Agent

Inside /baseai/memory/email-generator-memory.ts you’ll see another folder called documents. This is where you’ll store the files you want your AI agent to access. Let’s save your résumé as either a .pdf or .txt file. Then, I’ll convert it to a markdown file and place it in the /baseai/memory/email-generator-memory/documents directory.

This step ensures that the memory agent can process and retrieve information from your documents, making the AI agent capable of generating accurate cold emails based on the experiences and skills provided in the résumé attached.

Step 6: Generate Memory Embeddings

With your documents added to memory, the next step is generating memory embeddings. But before that, let me quickly explain what embeddings are and why they matter.

Understanding memory embeddings

Memory embeddings are numerical representations of your documents that enable an AI to grasp context, relationships, and meaning within text. They act as a bridge, converting raw data into a structured format AI can process for semantic search and retrieval.

Without embeddings, AI agents wouldn’t effectively connect user queries with relevant content. Generating embeddings creates a searchable index, allowing the memory agent to deliver accurate, context-aware responses efficiently.

How to generate embeddings

To generate embeddings for your documents, run the following command in your terminal:

npx baseai@latest embed -m email-generator-memory

Your memory is now ready to be connected with a Pipe (memory agent), enabling your AI agent to fetch precise, context-aware responses from your documents.

Step 7: Integrate Memory in Pipe Agent

Next, you have to attach the memory you created to your Pipe agent to make it a memory agent. For that, go to /baseai/pipes/email-generator-agent.ts. This is what it will look like at the moment:

import { PipeI } from '@baseai/core';

const pipePipeWithMemory = (): PipeI => ({
    apiKey: process.env.LANGBASE_API_KEY!, // Replace with your API key https://langbase.com/docs/api-reference/api-keys
    name: 'email-generator-agent',
    description: 'Generates emails for your dream job in seconds',
    status: 'public',
    model: 'openai:gpt-4o-mini',
    stream: true,
    json: false,
    store: true,
    moderate: true,
    top_p: 1,
    max_tokens: 1000,
    temperature: 0.7,
    presence_penalty: 1,
    frequency_penalty: 1,
    stop: [],
    tool_choice: 'auto',
    parallel_tool_calls: false,
    messages: [
        { role: 'system', content: You are a helpful AI assistant. }],
    variables: [],
    memory: [],
    tools: []
});

export default pipePipeWithMemory;

Now integrate the memory in the pipe by importing it at the top and calling it as a function in the memory array. Also, add the following in the messages content:

Based on the job description and my resume attached, write a compelling cold email tailored to the job, highlighting my most relevant skills, achievements, and experiences. Ensure the tone is professional yet approachable, and include a strong call to action for a follow-up or interview.

This is what the code will look like after doing all of this:

import { PipeI } from '@baseai/core';
import emailGeneratorMemoryMemory from '../memory/email-generator-memory';

const pipeEmailGeneratorAgent = (): PipeI => ({
 // Replace with your API key https://langbase.com/docs/api-reference/api-keys
 apiKey: process.env.LANGBASE_API_KEY!,
 name: 'email-generator-agent',
 description: 'Generates emails for your dream job in seconds',
 status: 'private',
 model: 'openai:gpt-4o-mini',
 stream: true,
 json: false,
 store: true,
 moderate: true,
 top_p: 1,
 max_tokens: 1000,
 temperature: 0.7,
 presence_penalty: 1,
 frequency_penalty: 1,
 stop: [],
 tool_choice: 'auto',
 parallel_tool_calls: true,
 messages: [{ role: 'system', content: Based on the job description and my resume attached, write a compelling cold email tailored to the job, highlighting my most relevant skills, achievements, and experiences. Ensure the tone is professional yet approachable, and include a strong call to action for a follow-up or interview. }],
 variables: [],
 memory: [emailGeneratorMemoryMemory()],
 tools: []
});

export default pipeEmailGeneratorAgent;

Step 8: Integrate the Memory Agent in Node.js

Now we’ll integrate the memory agent you created into the Node.js project to build an interactive command-line interface (CLI) for the document attached. This Node.js project will serve as the base for testing and interacting with the memory agent (in the beginning of the tutorial, we set up a Node.js project by initializing npm).

Now, create an index.ts file:

touch index.ts

In this TypeScript file, import the pipe agent you created. We will use the pipe primitive from @baseai/core to run the pipe.

Add the following code to the index.ts file:

import 'dotenv/config';
import { Pipe } from '@baseai/core';
import inquirer from 'inquirer';
import ora from 'ora';
import chalk from 'chalk';
import pipeEmailGeneratorAgent from './baseai/pipes/email-generator-agent';

const pipe = new Pipe(pipeEmailGeneratorAgent());

async function main() {

   const initialSpinner = ora('Conversation with Memory agent...').start();
   try {
       const { completion: calculatorTool} = await pipe.run({
           messages: [{ role: 'user', content: 'Hello' }],
       });
       initialSpinner.stop();
       console.log(chalk.cyan('Report Generator Agent response...'));
       console.log(calculatorTool);
   } catch (error) {
       initialSpinner.stop();
       console.error(chalk.red('Error processing initial request:'), error);
   }

   while (true) {
       const { userMsg } = await inquirer.prompt([
           {
               type: 'input',
               name: 'userMsg',
               message: chalk.blue('Enter your query (or type "exit" to quit):'),
           },
       ]);


       if (userMsg.toLowerCase() === 'exit') {
           console.log(chalk.green('Goodbye!'));
           break;
       }


       const spinner = ora('Processing your request...').start();


       try {
           const { completion: reportAgentResponse } = await pipe.run({
               messages: [{ role: 'user', content: userMsg }],
           });


           spinner.stop();
           console.log(chalk.cyan('Agent:'));
           console.log(reportAgentResponse);
       } catch (error) {
           spinner.stop();
           console.error(chalk.red('Error processing your request:'), error);
       }
   }
}

main();

This code creates an interactive CLI for chatting with an AI agent, using a pipe from the @baseai/core library to process user input. Here's what happens:

• It imports necessary libraries such as dotenv for environment configuration, inquirer for user input, ora for loading spinners, and chalk for colored output. Make sure you install these libraries first using this command in your terminal: npm install ora inquirer.

• A pipe object is created from the BaseAI library using a predefined memory called email-generator-agent.

In the main() function:

• A spinner starts while an initial conversation with the AI agent is initiated with the message 'Hello'.

• The response from the AI is displayed.

• A loop runs to continually ask the user for input and send queries to the AI agent.

• The AI's responses are shown, and the process continues until the user types "exit”.

Step 9: Start the BaseAI Server

To run the memory agent locally, you need to start the BaseAI server first. Run the following command in your terminal:

npx baseai@latest dev

Step 10: Run the Memory Agent

Run the index.ts file using the following command:

npx tsx index.ts

The Result

In your terminal, you’ll be prompted to "Enter your query." For example, let’s paste a job description and ask to generate an email from our end showing interest. And it will give us the response with correct sources/citations as well.

With this setup, we’ve built a Cold Email Generator agent that uses the power of LLMs and Langbase memory agents to overcome LLMs' limitations, ensuring accurate responses without hallucinating on private data.

Here’s a demo of the end result:

Thank you for reading!

Connect with me by 🙌:

• Subscribing to my YouTube Channel. If you are willing to learn about AI and agents.

• Subscribing to my free newsletter “The Agentic Engineer” where I share all the latest AI and agents news/trends/jobs and much more.

• Follow me on X (Twitter).