LangChain with TypeScript

import "dotenv/config";                  // load environment variables
import { createAgent } from "langchain";  // import createAgent

async function main() {
  console.log("Creating your first LangChain agent...\n");

  const agent = createAgent({
    model: "google-genai:gemini-flash-lite-latest",
    // model: "ollama:gemma2:2b",         // use local model (offline)
  });

  const result = await agent.invoke({
    messages: [
      {
        role: "user",
        content: "What is the capital of India?",
      },
    ],
  });

  // Print only the final response (clean output)
  const finalMessage = result.messages.at(-1);
  console.log("Agent Response:");
  console.log(finalMessage?.content);
}

main().catch(console.error);

import "dotenv/config";
import { createAgent } from "langchain";

async function main() {
  console.log("Understanding invoke and stream with multiple roles...\n");

  const agent = createAgent({
    model: "google-genai:gemini-flash-lite-latest",
  });

  const input = {
    messages: [
      {
        role: "system",
        content: "You are a software testing instructor.",
      },
      {
        role: "user",
        content: "Explain automation testing in two sentences.",
      },
    ],
  };

  // 1) invoke: wait for the full answer
  const result = await agent.invoke(input);
  console.log("Agent Response:");
  console.log(result.messages.at(-1)?.content);

  // 2) stream: print each token as it is generated
  console.log("\nStreaming Response:");
  for await (const [token] of await agent.stream(
    {
      messages: [
        { role: "system", content: "You are a software testing instructor." },
        { role: "user", content: "Explain smoke testing in two sentences." },
      ],
    },
    { streamMode: "messages" }
  )) {
    process.stdout.write(token.text ?? "");
  }
  console.log();
}

main().catch(console.error);

import "dotenv/config";
import { createAgent } from "langchain";

async function main() {
  const agent = createAgent({
    model: "google-genai:gemini-flash-lite-latest",
    systemPrompt: `You are a helpful AI assistant specialized in automation testing
      and software development. Be clear, concise, and always think step by step.`,
  });

  const result = await agent.invoke({
    messages: [{ role: "user", content: "Who are you?" }],
  });

  console.log("Agent Response:");
  console.log(result.messages.at(-1)?.content);
}

main().catch(console.error);

systemPrompt: `You are a senior automation testing engineer with 10+ years of experience.
  You specialize in Playwright, Appium, and API testing.
  Always think step by step and provide practical, production-ready solutions.`

import "dotenv/config";
import { createAgent } from "langchain";

interface AgentQuestion {
  id: number;
  topic: string;
  prompt: string;
}

async function main() {
  console.log("Creating LangChain agent...\n");

  // one agent with a strong system prompt, shared across all calls
  const agent = createAgent({
    model: "google-genai:gemini-flash-lite-latest",
    systemPrompt:
      "You are an experienced software testing instructor. " +
      "Explain each concept in exactly two sentences using simple language.",
  });

  const questions: AgentQuestion[] = [
    { id: 1, topic: "Smoke Testing", prompt: "What is smoke testing?" },
    { id: 2, topic: "Sanity Testing", prompt: "What is sanity testing?" },
    { id: 3, topic: "Regression Testing", prompt: "What is regression testing?" },
    // ... more questions
  ];

  const start = Date.now();

  // Promise.all() runs all agent.invoke() calls CONCURRENTLY
  const results = await Promise.all(
    questions.map((q) =>
      agent.invoke({ messages: [{ role: "user", content: q.prompt }] })
    )
  );

  // Process results in order using the original array
  results.forEach((result, index) => {
    const q = questions[index];
    console.log(`${q.id}. ${q.topic}`);
    console.log(result.messages.at(-1)?.content);
    console.log("-".repeat(70));
  });

  console.log(`Finished ${questions.length} calls in ${(Date.now() - start) / 1000}s`);
}

main().catch(console.error);

import "dotenv/config";                        // load environment variables (.env)
import { createAgent, tool } from "langchain"; // LangChain core
import * as z from "zod";                      // for schema validation

const calculatorTool = tool(
  ({ expression }) => {
    try {
      return String(eval(expression));
      // Demo only: use math.js or any safe math library in real projects
    } catch (e) {
      return "Error: Invalid mathematical expression";
    }
  },
  {
    name: "calculator",
    description:
      "Useful for performing mathematical calculations. " +
      "Input should be a valid math expression like '25 * 4' or '100 / 2'.",
    schema: z.object({
      expression: z.string().describe("The mathematical expression to evaluate"),
    }),
  }
);

async function main() {
  const agent = createAgent({
    model: "google-genai:gemini-flash-lite-latest",
    tools: [calculatorTool],
    systemPrompt: `You are a helpful automation testing assistant.
      Use the calculator tool whenever math is required.
      Always be helpful and accurate.`,
  });

  const queries = [
    "What is 15 multiplied by 24?",   // Math  -> agent uses calculator
    "Calculate 100 divided by 4",     // Math  -> agent uses calculator
    "What is the capital of India?",  // General -> should NOT use calculator
  ];

  for (const q of queries) {
    console.log(`\nQuestion: ${q}`);
    const result = await agent.invoke({
      messages: [{ role: "user", content: q }],
    });
    console.log("Agent:", result.messages.at(-1)?.content);
  }
}

main().catch(console.error);

import "dotenv/config";                        // loads .env variables (API keys)
import { createAgent, tool } from "langchain"; // helps create custom tools
import * as z from "zod";                      // for input validation
import axios from "axios";                     // to call external APIs

// Tool 1: Search Tool - uses DuckDuckGo and returns the page title
const searchTool = tool(
  async ({ query }) => {
    try {
      const res = await axios.get(
        `https://duckduckgo.com/?q=${encodeURIComponent(query)}`
      );
      return res.data.split("<title>")[1].split("</title>")[0];
    } catch (e) {
      return "Error performing search";
    }
  },
  {
    name: "search_web",
    description: "Search the web for a query and return the results page title",
    schema: z.object({
      query: z.string().describe("The search query"),
    }),
  }
);

// Tool 2: Web Content Tool - fetches a URL and returns plain text (first 1000 chars)
const webContentTool = tool(
  async ({ url }) => {
    try {
      const res = await axios.get(url);
      const text = res.data.replace(/<[^>]*>/g, "");
      return text.substring(0, 1000);
    } catch (e) {
      return "Error fetching web content";
    }
  },
  {
    name: "get_web_content",
    description: "Fetch the content of a web page from a URL as plain text",
    schema: z.object({
      url: z.string().describe("The full URL to fetch"),
    }),
  }
);

async function main() {
  const agent = createAgent({
    model: "google-genai:gemini-flash-lite-latest",
    tools: [searchTool, webContentTool],   // we pass both tools in the tools array
    systemPrompt: `You are a helpful automation testing assistant.
      Use the available tools to search the web and fetch content when needed.`,
  });

  const queries = [
    "What is Playwright?",                          // general info (may use search)
    "Search for Appium official website",           // needs search
    "Get content from https://playwright.dev docs", // needs web content tool
  ];

  for (const q of queries) {
    const result = await agent.invoke({
      messages: [{ role: "user", content: q }],
    });
    console.log(`\nQ: ${q}`);
    console.log(`Agent: ${result.messages.at(-1)?.content}`);
  }
}

main().catch(console.error);

import "dotenv/config";
import { createAgent } from "langchain";
import * as z from "zod";

// Anthropic requires the top-level response schema to be an object,
// so wrap the array of test cases inside an object.
const TestCaseSchema = z.object({
  testCases: z.array(
    z.object({
      title: z.string(),
      description: z.string(),
      steps: z.array(z.string()),
      expectedResult: z.string(),
      priority: z.enum(["High", "Medium", "Low"]),
      tags: z.array(z.string()),
    })
  ),
});

async function main() {
  const agent = createAgent({
    model: "anthropic:claude-haiku-4-5",
    // model: "ollama:llama3.2",             // optional
    systemPrompt: `You are a senior automation testing engineer.
      Always return test cases in the exact structured JSON format requested.
      Be detailed and professional.`,
    responseFormat: TestCaseSchema,          // enforce the Zod schema on the output
  });

  const userStory = `As a logged-in user, I want to add items to my shopping cart
    so that I can purchase them later.`;

  const result = await agent.invoke({
    messages: [
      {
        role: "user",
        content: `Generate 2 detailed test cases for this user story: ${userStory}`,
      },
    ],
  });

  console.log("=== Structured Output ===");
  console.dir(result.structuredResponse, { depth: null });

  const testCases = result.structuredResponse.testCases;
  console.log(`\nSuccessfully generated ${testCases.length} test cases!`);
}

main().catch(console.error);

import "dotenv/config";
import { createAgent } from "langchain";

async function main() {
  const agent = createAgent({
    model: "anthropic:claude-haiku-4-5",
    systemPrompt: "You are a helpful automation testing assistant.",
  });

  console.log("=== Turn 1 ===");
  let result = await agent.invoke({
    messages: [
      { role: "user", content: "I need to test the login functionality using Playwright typescript." },
    ],
  });
  console.log("Agent:", result.messages.at(-1)?.content);

  console.log("\n=== Turn 2 (No Memory) ===");
  result = await agent.invoke({
    messages: [{ role: "user", content: "What test cases should I write?" }],
  });
  console.log("Agent:", result.messages.at(-1)?.content);
}

main().catch(console.error);

import "dotenv/config";
import { createAgent } from "langchain";
import { MemorySaver } from "@langchain/langgraph";

async function main() {
  const checkpointer = new MemorySaver();

  const agent = createAgent({
    model: "anthropic:claude-haiku-4-5",
    systemPrompt: "You are a helpful automation testing assistant.",
    checkpointer,                                  // 1) where the history is stored
  });

  const threadId = "test-session-1";               // 2) which conversation to use

  console.log("=== Turn 1 ===");
  let result = await agent.invoke(
    { messages: [{ role: "user", content: "I need to test the login functionality using Playwright typescript." }] },
    { configurable: { thread_id: threadId } }
  );
  console.log("Agent:", result.messages.at(-1)?.content);

  console.log("\n=== Turn 2 (with Memory) ===");
  result = await agent.invoke(
    { messages: [{ role: "user", content: "What test cases should I write?" }] },
    { configurable: { thread_id: threadId } }
  );
  console.log("Agent:", result.messages.at(-1)?.content);
}

main().catch(console.error);

npm install @langchain/langgraph-checkpoint-sqlite

import "dotenv/config";
import { createAgent } from "langchain";
import { SqliteSaver } from "@langchain/langgraph-checkpoint-sqlite";
import { ChatAnthropic } from "@langchain/anthropic";

async function main() {
  console.log("Step 1: Creating a new session with memory...");

  const checkpointer = SqliteSaver.fromConnString("./memory.db");

  const model = new ChatAnthropic({
    model: "claude-haiku-4-5",
    temperature: 0.9,         // 0 to 1 - use 0.1 to 0.3 for precise, factual answers
    maxTokens: 1000,
  });

  const agent = createAgent({
    model,
    systemPrompt: `You are a helpful automation testing assistant.
      Always remember the previous conversation and provide relevant suggestions.`,
    checkpointer,
  });

  const threadId = "demo-persistent-memory";

  const conversation = [
    "I need to test the login functionality using Playwright typescript.",
    "What test cases should I write?",
    "Can you provide me with a sample test case for the login functionality?",
  ];

  for (const [index, message] of conversation.entries()) {
    console.log(`\n=== Turn ${index + 1} ===`);
    console.log("You:", message);

    const result = await agent.invoke(
      { messages: [{ role: "user", content: message }] },
      { configurable: { thread_id: threadId } }
    );

    console.log("Agent:", result.messages.at(-1)?.content);
  }
}

main().catch(console.error);

import "dotenv/config";
import { createAgent } from "langchain";
import { SqliteSaver } from "@langchain/langgraph-checkpoint-sqlite";
import { ChatAnthropic } from "@langchain/anthropic";

async function main() {
  console.log("Step 2: Continuing from the previous session with memory...");

  const checkpointer = SqliteSaver.fromConnString("./memory.db");

  const model = new ChatAnthropic({
    model: "claude-haiku-4-5",
    temperature: 0.1,
    maxTokens: 1000,
  });

  const agent = createAgent({
    model,
    systemPrompt: `You are a helpful automation testing assistant.
      Always remember the previous conversation and provide relevant suggestions.`,
    checkpointer,
  });

  const threadId = "demo-persistent-memory";   // same thread as session 1

  const followUp =
    "What were we discussing earlier? Can you summarize the previous conversation and provide the next steps?";

  console.log("You:", followUp);

  const result = await agent.invoke(
    { messages: [{ role: "user", content: followUp }] },
    { configurable: { thread_id: threadId } }
  );

  console.log("\nAgent remembers:\n", result.messages.at(-1)?.content);
  console.log("\nMemory is persistent across sessions!\n");
}

main().catch(console.error);

import { SqliteSaver } from "@langchain/langgraph-checkpoint-sqlite";

async function clear() {
  const checkpointer = SqliteSaver.fromConnString("./memory.db");

  await checkpointer.deleteThread("demo-persistent-memory");

  console.log("Memory cleared for thread: demo-persistent-memory");
}

clear().catch(console.error);

import "dotenv/config";
import { Annotation, END, START, StateGraph } from "@langchain/langgraph";
import { ChatAnthropic } from "@langchain/anthropic";

// ================
// 1. Shared State
// ================
const MultiAgentState = Annotation.Root({
  request: Annotation<string>,
  testCases: Annotation<string>,
  review: Annotation<string>,
  finalOutput: Annotation<string>,
  next: Annotation<string>,
});

// ================
// 2. Model
// ================
const model = new ChatAnthropic({
  model: "claude-haiku-4-5",
  temperature: 0.2,
  maxTokens: 1500,
});

// ================
// 3. Worker: Generator Agent
// ================
async function generatorNode(state: typeof MultiAgentState.State) {
  console.log("Generator Worker: Creating test cases...");

  const prompt = `You are a Test Case Generator Agent.

  User request: ${state.request}

  Generate 3 clear test cases.
  For each test case include:
  - Title
  - Type (Positive/Negative/Edge Case)
  - Preconditions
  - Steps
  - Expected Result`;

  const response = await model.invoke(prompt);
  const content =
    typeof response.content === "string"
      ? response.content
      : JSON.stringify(response.content);

  return { testCases: content, next: "supervisor" };
}

// ================
// 4. Worker: Reviewer Agent
// ================
async function reviewerNode(state: typeof MultiAgentState.State) {
  console.log("Reviewer Worker: Reviewing test cases...");

  const prompt = `You are a Test Case Reviewer Agent.

  Review the following test cases generated by the Generator Agent and improve them.
  Focus on:
  - missing negative scenarios
  - clarity of steps
  - expected results
  - practical QA quality

  Test Cases:
  ${state.testCases}

  Return the improved test cases in a clear format.`;

  const response = await model.invoke(prompt);
  const content =
    typeof response.content === "string"
      ? response.content
      : JSON.stringify(response.content);

  return { review: content, finalOutput: content, next: "supervisor" };
}

// ================
// 5. Supervisor Agent
// ================
async function supervisorNode(state: typeof MultiAgentState.State) {
  console.log("Supervisor: Deciding next step...");

  // If test cases are not generated yet, go to generator
  if (!state.testCases) {
    return { next: "generator" };
  }
  // If review is not done yet, go to reviewer
  if (!state.review) {
    return { next: "reviewer" };
  }

  console.log("Supervisor: All steps completed. Final output ready.");
  return {
    next: "end",
    finalOutput: state.finalOutput || state.review || state.testCases,
  };
}

// ================
// 6. Routing Function
// ================
function routeSupervisor(state: typeof MultiAgentState.State) {
  if (state.next === "generator") return "generator";
  if (state.next === "reviewer") return "reviewer";
  return END;
}

// ================
// 7. Build the Graph
// ================
const workflow = new StateGraph(MultiAgentState)
  .addNode("supervisor", supervisorNode)
  .addNode("generator", generatorNode)
  .addNode("reviewer", reviewerNode)

  .addEdge(START, "supervisor")
  .addConditionalEdges("supervisor", routeSupervisor, {
    generator: "generator",
    reviewer: "reviewer",
    [END]: END,
  })

  .addEdge("generator", "supervisor")
  .addEdge("reviewer", "supervisor");

const graph = workflow.compile();

async function main() {
  console.log("Starting Multi-Agent Workflow...");

  const result = await graph.invoke({
    request:
      "Create test cases for a login feature for a web application. Include positive, negative, and edge cases.",
    // empty initial state for the other fields
    testCases: "",
    review: "",
    finalOutput: "",
    next: "",
  });

  console.log("Final Output from Multi-Agent Workflow:");
  console.log(result.finalOutput || result.review || result.testCases);
}

main().catch(console.error);

npm install @langchain/classic @langchain/textsplitters
ollama pull nomic-embed-text        # free local embedding model

Login Feature Requirements

The login feature allows registered users to access the application.

Acceptance Criteria:
1. The user must be able to enter their username and password.
2. The system must validate the credentials against the database.
3. The system must display an error message for invalid credentials.
4. After 3 failed login attempts, the user account should be locked for 15 minutes.
5. On successful login, the user should be redirected to the dashboard.
6. Passwords must be stored securely using hashing algorithms.
7. Password must be at least 8 characters long.

Business Rules:
- Guest users cannot access the login feature.
- The system should log all login attempts for security auditing.
- The login feature must comply with the company's security policies and standards.
- Login session expires after 30 minutes of inactivity.
- Forgot password link should be available on the login page to reset the password.

import "dotenv/config";

// Represents a document object that LangChain understands
import { Document } from "@langchain/core/documents";
// Splits large text into smaller overlapping chunks
import { RecursiveCharacterTextSplitter } from "@langchain/textsplitters";
// Converts text into numerical vectors (embeddings) using Ollama - local FREE model
import { OllamaEmbeddings } from "@langchain/ollama";
// In-memory vector store to hold embeddings and perform similarity search
import { MemoryVectorStore } from "@langchain/classic/vectorstores/memory";
// Helps us create structured prompts for LLMs
import { ChatPromptTemplate } from "@langchain/core/prompts";
// Combines retrieved documents into a single input for the LLM
import { createStuffDocumentsChain } from "@langchain/classic/chains/combine_documents";
// Connects retriever + document chain to form a complete RAG pipeline
import { createRetrievalChain } from "@langchain/classic/chains/retrieval";
import { ChatAnthropic } from "@langchain/anthropic";
import * as fs from "fs";

async function main() {
  console.log("RAG Pipeline Example");

  // 1. Load the document
  const sampleDocument = fs.readFileSync("./documents/login-requirements.txt", "utf-8");

  const documents = [
    new Document({
      pageContent: sampleDocument,
      metadata: { source: "login-requirements.txt" },
    }),
  ];
  console.log("Document Loaded");

  // 2. Split the document into chunks
  const textSplitter = new RecursiveCharacterTextSplitter({
    chunkSize: 300,      // each chunk has a maximum of 300 characters
    chunkOverlap: 50,    // each chunk overlaps the next by 50 characters
  });

  const splits = await textSplitter.splitDocuments(documents);
  console.log("Document split into", splits.length, "chunks.");

  // 3. Create embeddings + vector store
  const embeddings = new OllamaEmbeddings({
    model: "nomic-embed-text",
    baseUrl: "http://localhost:11434",
  });

  const vectorStore = await MemoryVectorStore.fromDocuments(splits, embeddings);
  console.log("--- Vector store created using Ollama embeddings ---");

  // 4. Create the retriever
  const retriever = vectorStore.asRetriever({ k: 2 });  // top 2 most relevant chunks

  // 5. Create the LLM
  const model = new ChatAnthropic({
    model: "claude-haiku-4-5",
    temperature: 0.2,
    maxTokens: 1500,
  });

  // 6. Create the prompt template
  // {context} is replaced with the retrieved chunks, {input} with the user question
  const prompt = ChatPromptTemplate.fromTemplate(`
    You are a helpful assistant for software testing.
    Answer the question based only on the following context provided from the document.
    If the answer is not contained within the context, say
    "I don't have enough information in the document".

    Context:
    {context}

    Question: {input}`);

  // 7. Create the document chain
  const documentChain = await createStuffDocumentsChain({
    llm: model,
    prompt: prompt,
  });

  // 8. Create the full RAG chain
  // Retriever (find relevant chunks) + Document chain (send chunks to LLM)
  const ragChain = await createRetrievalChain({
    retriever,
    combineDocsChain: documentChain,
  });

  // 9. Ask questions
  const questions = [
    "What are the acceptance criteria for the login feature?",
    "What happens after 3 failed login attempts?",
    "Is password hashing required?",
    "Can guest users access the login feature?",
    "What is the maximum file upload size?",   // not in the document
  ];

  for (const question of questions) {
    console.log("\n--------------------------------------------------");
    console.log(`Question: ${question}`);
    const result = await ragChain.invoke({ input: question });
    console.log("Answer:", result.answer);
  }
}

main().catch(console.error);

npm install @modelcontextprotocol/sdk @langchain/mcp-adapters

/*
 3 important parts:
 1. Create the server
 2. Create tools / list tools / handle tool calls
 3. Start the server with stdio transport
*/

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

// 1. Create the MCP server
const server = new McpServer({
  name: "QA Utils Server",
  version: "1.0.0",
});

// 2. Register tools

// Tool 1: Generate a random test email address
server.registerTool(
  "generate_test_email",
  {
    description: "Generate a random test email address useful for automation testing.",
    inputSchema: z.object({}),
  },
  async () => {
    const random = Math.floor(Math.random() * 10000);
    const email = `test.user_${random}@example.com`;
    return { content: [{ type: "text", text: email }] };
  }
);

// Tool 2: Generate a strong test password
server.registerTool(
  "generate_test_password",
  {
    description: "Generate a strong test password useful for automation testing.",
    inputSchema: z.object({}),
  },
  async () => {
    const random = Math.floor(Math.random() * 10000);
    const password = `Test@${random}Password!`;
    return { content: [{ type: "text", text: password }] };
  }
);

// Tool 3: Generate a mobile number
server.registerTool(
  "generate_mobile_number",
  {
    description: "Generate a random mobile number useful for automation testing.",
    inputSchema: z.object({}),
  },
  async () => {
    const random = Math.floor(Math.random() * 10000);
    const mobileNumber = `+1-555-000-${random.toString().padStart(4, "0")}`;
    return { content: [{ type: "text", text: mobileNumber }] };
  }
);

// Tool 4: Add numbers
server.registerTool(
  "add_numbers",
  {
    description: "Add two numbers together and return the sum.",
    inputSchema: z.object({
      a: z.number().describe("First number to add"),
      b: z.number().describe("Second number to add"),
    }),
  },
  async ({ a, b }) => {
    const sum = a + b;
    return { content: [{ type: "text", text: sum.toString() }] };
  }
);

// 3. Start the server with stdio transport
async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("QA Utils Server is running. Waiting for requests...");
}

main().catch((error) => {
  console.error("Error starting the server:", error);
  process.exit(1);
});

import "dotenv/config";
import { createAgent } from "langchain";
import { MultiServerMCPClient } from "@langchain/mcp-adapters";
import path from "path";

async function main() {
  console.log("------- Using MCP tools with a LangChain agent -------");

  // 1. Connect to the MCP server
  const client = new MultiServerMCPClient({
    qaUtils: {
      transport: "stdio",
      command: "npx",
      args: ["tsx", path.resolve("./mcp-servers/qa-utils-server.ts")],
    },
  });

  // Load all tools exposed by the MCP server
  const tools = await client.getTools();
  console.log("Tools loaded from MCP server:", tools.map((t) => t.name));

  // 2. Create the agent with the MCP tools
  const agent = createAgent({
    model: "anthropic:claude-haiku-4-5",
    tools,
    systemPrompt: `You are a helpful QA Automation Assistant.
      You have access to MCP tools for generating test emails, strong passwords,
      mobile numbers, and adding numbers.

      Rules:
      1. When the user asks for test data, use the MCP tools.
      2. When the user asks a general testing question, answer from your knowledge.
      3. Be clear and concise.`,
  });

  // 3. Demo questions
  const questions = [
    "Generate a test email for me",
    "Generate a strong password for me",
    "Generate a mobile number for me",
    "Add 123 and 456 for me",
    "What is the best way to test a web application?",
  ];

  for (const question of questions) {
    console.log("\n----------------------------");
    console.log("Q:", question);
    const result = await agent.invoke({
      messages: [{ role: "user", content: question }],
    });
    console.log("Agent:", result.messages.at(-1)?.content);
  }

  await client.close();   // close the connection to the MCP server
}

main().catch(console.error);

{
  "servers": {
    "qa-utils-server": {
      "type": "stdio",
      "command": "npx",
      "args": ["tsx", "./mcp-servers/qa-utils-server.ts"]
    }
  }
}

npm install playwright
npx playwright install chromium       # downloads the browser Playwright will drive

import { tool } from "langchain";
import { z } from "zod";
import { chromium, Browser, Page } from "playwright";

// Global variables (shared across tools)
let browser: Browser | null = null;
let page: Page | null = null;

// ============================================
// Playwright Tools
// ============================================

export const launchBrowser = tool(
  async () => {
    if (browser) return "Browser is already open.";

    browser = await chromium.launch({
      headless: false,
      slowMo: 700,
    });

    const context = await browser.newContext();
    page = await context.newPage();

    return "Browser launched successfully (visible mode).";
  },
  {
    name: "launch_browser",
    description: "Launch a visible Chromium browser. Always call this first.",
    schema: z.object({}),
  }
);

export const navigateTo = tool(
  async ({ url }) => {
    if (!page) return "Error: Browser not launched. Call launch_browser first.";
    await page.goto(url, { waitUntil: "domcontentloaded" });
    return `Navigated to ${url}`;
  },
  {
    name: "navigate_to",
    description: "Navigate to a URL",
    schema: z.object({
      url: z.string().url().describe("Full URL to open"),
    }),
  }
);

export const typeText = tool(
  async ({ selector, text }) => {
    if (!page) return "Error: Browser not launched.";
    await page.fill(selector, text);
    return `Typed "${text}" into ${selector}`;
  },
  {
    name: "type_text",
    description: "Type text into an input field",
    schema: z.object({
      selector: z.string().describe("CSS selector"),
      text: z.string().describe("Text to type"),
    }),
  }
);

export const clickElement = tool(
  async ({ selector }) => {
    if (!page) return "Error: Browser not launched.";
    await page.click(selector);
    return `Clicked on ${selector}`;
  },
  {
    name: "click_element",
    description: "Click on an element",
    schema: z.object({
      selector: z.string().describe("CSS selector of element to click"),
    }),
  }
);

export const getText = tool(
  async ({ selector }) => {
    if (!page) return "Error: Browser not launched.";
    const text = await page.textContent(selector);
    return text || "No text found";
  },
  {
    name: "get_text",
    description: "Extract text from an element",
    schema: z.object({
      selector: z.string().describe("CSS selector"),
    }),
  }
);

export const takeScreenshot = tool(
  async ({ filename = "screenshot.png" }) => {
    if (!page) return "Error: Browser not launched.";
    const path = `./screenshots/${filename}`;
    await page.screenshot({ path, fullPage: true });
    return `Screenshot saved as ${path}`;
  },
  {
    name: "take_screenshot",
    description: "Take a full page screenshot",
    schema: z.object({
      filename: z.string().optional().describe("Filename for screenshot"),
    }),
  }
);

export const closeBrowser = tool(
  async () => {
    if (browser) {
      await browser.close();
      browser = null;
      page = null;
      return "Browser closed successfully.";
    }
    return "No browser is open.";
  },
  {
    name: "close_browser",
    description: "Close the browser",
    schema: z.object({}),
  }
);

import "dotenv/config";
import { createAgent } from "langchain";
import { ChatAnthropic } from "@langchain/anthropic";

import {
  launchBrowser,
  navigateTo,
  typeText,
  clickElement,
  getText,
  closeBrowser,
  takeScreenshot,
} from "./playwright-tools.js";

async function main() {
  const model = new ChatAnthropic({
    model: "claude-haiku-4-5",
    temperature: 0.2,
    maxTokens: 1500,
  });

  const agent = createAgent({
    model,
    tools: [
      launchBrowser,
      navigateTo,
      typeText,
      clickElement,
      getText,
      closeBrowser,
      takeScreenshot,
    ],
    systemPrompt: `You are an automation testing agent that controls a real browser
      using Playwright.

      Rules:
      1. Always start with launching a browser before performing any actions.
      2. Perform actions in the order they are requested.
      3. Take a screenshot before closing the browser to capture the final state.
      4. Use clear CSS selectors for interacting with elements on the page.
      5. Explain each action you take, and report whether the test PASSED or FAILED.`,
  });

  const task = `Test the login functionality on https://the-internet.herokuapp.com/login:

    1. Launch Browser
    2. Navigate to the login page
    3. Enter username "tomsmith"
    4. Enter password "SuperSecretPassword!"
    5. Click the login button
    6. Verify successful login by reading the flash message
    7. Take a screenshot named "login_test_result.png"
    8. Close Browser`;

  const result = await agent.invoke({
    messages: [{ role: "user", content: task }],
  });

  // Show each tool call and what the browser answered
  console.log("\n===== Steps taken =====");
  for (const msg of result.messages) {
    const type = msg.getType();
    if (type === "ai" && msg.tool_calls?.length) {
      for (const call of msg.tool_calls) {
        console.log(`-> ${call.name}(${JSON.stringify(call.args)})`);
      }
    } else if (type === "tool") {
      console.log(`   ${msg.content}`);
    }
  }

  console.log("\n===== Final Result =====");
  console.log(result.messages.at(-1)?.content);
}

main().catch(console.error);