langchain-hello-world

Create a minimal working LangChain example with LCEL chains. Use when starting a new LangChain integration, testing your setup, or learning LCEL pipe syntax with prompts and output parsers. Trigger: "langchain hello world", "langchain example", "langchain quick start", "simple langchain code", "first langchain app".

Quality

83%

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Passed

No known issues

LangChain Hello World

Overview

Minimal working examples demonstrating LCEL (LangChain Expression Language) -- the .pipe() chain syntax that is the foundation of all LangChain applications.

Prerequisites

Completed langchain-install-auth setup
Valid LLM provider API key configured

Example 1: Simplest Chain (TypeScript)

import { ChatOpenAI } from "@langchain/openai";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { StringOutputParser } from "@langchain/core/output_parsers";

// Three components: prompt -> model -> parser
const prompt = ChatPromptTemplate.fromTemplate("Tell me a joke about {topic}");
const model = new ChatOpenAI({ model: "gpt-4o-mini" });
const parser = new StringOutputParser();

// LCEL: chain them with .pipe()
const chain = prompt.pipe(model).pipe(parser);

const result = await chain.invoke({ topic: "TypeScript" });
console.log(result);
// "Why do TypeScript developers wear glasses? Because they can't C#!"

Example 2: Chat with System Prompt

import { ChatOpenAI } from "@langchain/openai";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { StringOutputParser } from "@langchain/core/output_parsers";

const prompt = ChatPromptTemplate.fromMessages([
  ["system", "You are a {persona}. Keep answers under 50 words."],
  ["human", "{question}"],
]);

const chain = prompt
  .pipe(new ChatOpenAI({ model: "gpt-4o-mini" }))
  .pipe(new StringOutputParser());

const answer = await chain.invoke({
  persona: "senior DevOps engineer",
  question: "What is the most important Kubernetes concept?",
});
console.log(answer);

Example 3: Structured Output with Zod

import { ChatOpenAI } from "@langchain/openai";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { z } from "zod";

const ReviewSchema = z.object({
  sentiment: z.enum(["positive", "negative", "neutral"]),
  confidence: z.number().min(0).max(1),
  summary: z.string().describe("One-sentence summary"),
});

const model = new ChatOpenAI({ model: "gpt-4o-mini" });
const structuredModel = model.withStructuredOutput(ReviewSchema);

const prompt = ChatPromptTemplate.fromTemplate(
  "Analyze the sentiment of this review:\n\n{review}"
);

const chain = prompt.pipe(structuredModel);

const result = await chain.invoke({
  review: "LangChain makes building AI apps surprisingly straightforward.",
});
console.log(result);
// { sentiment: "positive", confidence: 0.92, summary: "..." }

Example 4: Streaming

import { ChatOpenAI } from "@langchain/openai";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { StringOutputParser } from "@langchain/core/output_parsers";

const chain = ChatPromptTemplate.fromTemplate("Write a haiku about {topic}")
  .pipe(new ChatOpenAI({ model: "gpt-4o-mini" }))
  .pipe(new StringOutputParser());

// Stream tokens as they arrive
const stream = await chain.stream({ topic: "coding" });
for await (const chunk of stream) {
  process.stdout.write(chunk);
}

Example 5: Python Equivalent

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

prompt = ChatPromptTemplate.from_template("Tell me about {topic}")
model = ChatOpenAI(model="gpt-4o-mini")
parser = StrOutputParser()

# LCEL uses | operator in Python
chain = prompt | model | parser

result = chain.invoke({"topic": "LangChain"})
print(result)

How LCEL Works

Every component in an LCEL chain implements the Runnable interface:

Method	Purpose
`.invoke(input)`	Single input, single output
`.batch(inputs)`	Process array of inputs
`.stream(input)`	Yield output chunks
`.pipe(next)`	Chain to next runnable

The .pipe() method (or | in Python) creates a RunnableSequence where each step's output feeds the next step's input. Every LangChain component -- prompts, models, parsers, retrievers -- is a Runnable.

Error Handling

Error	Cause	Fix
`Missing value for input topic`	Template variable not in invoke args	Match `invoke({})` keys to template `{variables}`
`Cannot read properties of undefined`	Chain not awaited	Add `await` before `.invoke()`
`Rate limit reached`	Too many API calls	Add delay or use `gpt-4o-mini` for testing

Resources

Next Steps

Proceed to langchain-core-workflow-a for advanced chain composition.

Repository: jeremylongshore/claude-code-plugins-plus-skills
Commit: 3a2d27d

Last updated: 2 days ago
Created: 2 days ago

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.