Skip to main content

LangChain Expression Language Cheatsheet

This is a quick reference for all the most important LCEL primitives. For more advanced usage see the LCEL how-to guides and the full API reference.

Invoke a runnable​

runnable.invoke()​

import { RunnableLambda } from "@langchain/core/runnables";

const runnable = RunnableLambda.from((x: number) => x.toString());

await runnable.invoke(5);
"5"

Batch a runnable​

runnable.batch()​

import { RunnableLambda } from "@langchain/core/runnables";

const runnable = RunnableLambda.from((x: number) => x.toString());

await runnable.batch([7, 8, 9]);
[ "7", "8", "9" ]

Stream a runnable​

runnable.stream()​

import { RunnableLambda } from "@langchain/core/runnables";

async function* generatorFn(x: number[]) {
for (const i of x) {
yield i.toString();
}
}

const runnable = RunnableLambda.from(generatorFn);

const stream = await runnable.stream([0, 1, 2, 3, 4]);

for await (const chunk of stream) {
console.log(chunk);
console.log("---");
}
0
---
1
---
2
---
3
---
4
---

Compose runnables​

runnable.pipe()​

import { RunnableLambda } from "@langchain/core/runnables";

const runnable1 = RunnableLambda.from((x: any) => {
return { foo: x };
});

const runnable2 = RunnableLambda.from((x: any) => [x].concat([x]));

const chain = runnable1.pipe(runnable2);

await chain.invoke(2);
[ { foo: 2 }, { foo: 2 } ]

RunnableSequence.from()​

import { RunnableLambda, RunnableSequence } from "@langchain/core/runnables";

const runnable1 = RunnableLambda.from((x: any) => {
return { foo: x };
});

const runnable2 = RunnableLambda.from((x: any) => [x].concat([x]));

const chain = RunnableSequence.from([runnable1, runnable2]);

await chain.invoke(2);
[ { foo: 2 }, { foo: 2 } ]

Invoke runnables in parallel​

RunnableParallel​

import { RunnableLambda, RunnableParallel } from "@langchain/core/runnables";

const runnable1 = RunnableLambda.from((x: any) => {
return { foo: x };
});

const runnable2 = RunnableLambda.from((x: any) => [x].concat([x]));

const chain = RunnableParallel.from({
first: runnable1,
second: runnable2,
});

await chain.invoke(2);
{ first: { foo: 2 }, second: [ 2, 2 ] }

Turn a function into a runnable​

RunnableLambda​

import { RunnableLambda } from "@langchain/core/runnables";

const adder = (x: number) => {
return x + 5;
};

const runnable = RunnableLambda.from(adder);

await runnable.invoke(5);
10

Merge input and output dicts​

RunnablePassthrough.assign()​

import { RunnableLambda, RunnablePassthrough } from "@langchain/core/runnables";

const runnable = RunnableLambda.from((x: { foo: number }) => {
return x.foo + 7;
});

const chain = RunnablePassthrough.assign({
bar: runnable,
});

await chain.invoke({ foo: 10 });
{ foo: 10, bar: 17 }

Include input dict in output dict​

RunnablePassthrough​

import {
RunnableLambda,
RunnableParallel,
RunnablePassthrough,
} from "@langchain/core/runnables";

const runnable = RunnableLambda.from((x: { foo: number }) => {
return x.foo + 7;
});

const chain = RunnableParallel.from({
bar: runnable,
baz: new RunnablePassthrough(),
});

await chain.invoke({ foo: 10 });
{ baz: { foo: 10 }, bar: 17 }

Add default invocation args​

runnable.bind()​

import { type RunnableConfig, RunnableLambda } from "@langchain/core/runnables";

const branchedFn = (mainArg: Record<string, any>, config?: RunnableConfig) => {
if (config?.configurable?.boundKey !== undefined) {
return { ...mainArg, boundKey: config?.configurable?.boundKey };
}
return mainArg;
};

const runnable = RunnableLambda.from(branchedFn);
const boundRunnable = runnable.bind({ configurable: { boundKey: "goodbye!" } });

await boundRunnable.invoke({ bar: "hello" });
{ bar: "hello", boundKey: "goodbye!" }

Add fallbacks​

runnable.withFallbacks()​

import { RunnableLambda } from "@langchain/core/runnables";

const runnable = RunnableLambda.from((x: any) => {
throw new Error("Error case");
});

const fallback = RunnableLambda.from((x: any) => x + x);

const chain = runnable.withFallbacks({ fallbacks: [fallback] });

await chain.invoke("foo");
"foofoo"

Add retries​

runnable.withRetry()​

import { RunnableLambda } from "@langchain/core/runnables";

let counter = 0;

const retryFn = (_: any) => {
counter++;
console.log(`attempt with counter ${counter}`);
throw new Error("Expected error");
};

const chain = RunnableLambda.from(retryFn).withRetry({
stopAfterAttempt: 2,
});

await chain.invoke(2);
attempt with counter 1
attempt with counter 2
Error: Expected error

Configure runnable execution​

RunnableConfig​

import { RunnableLambda } from "@langchain/core/runnables";

const runnable1 = RunnableLambda.from(async (x: any) => {
await new Promise((resolve) => setTimeout(resolve, 2000));
return { foo: x };
});

// Takes 4 seconds
await runnable1.batch([1, 2, 3], { maxConcurrency: 2 });
[ { foo: 1 }, { foo: 2 }, { foo: 3 } ]

Add default config to runnable​

runnable.withConfig()​

import { RunnableLambda } from "@langchain/core/runnables";

const runnable1 = RunnableLambda.from(async (x: any) => {
await new Promise((resolve) => setTimeout(resolve, 2000));
return { foo: x };
}).withConfig({
maxConcurrency: 2,
});

// Takes 4 seconds
await runnable1.batch([1, 2, 3]);
[ { foo: 1 }, { foo: 2 }, { foo: 3 } ]

Build a chain dynamically based on input​

import { RunnableLambda } from "@langchain/core/runnables";

const runnable1 = RunnableLambda.from((x: any) => {
return { foo: x };
});

const runnable2 = RunnableLambda.from((x: any) => [x].concat([x]));

const chain = RunnableLambda.from((x: number): any => {
if (x > 6) {
return runnable1;
}
return runnable2;
});

await chain.invoke(7);
{ foo: 7 }
await chain.invoke(5);
[ 5, 5 ]

Generate a stream of internal events​

runnable.streamEvents()​

import { RunnableLambda } from "@langchain/core/runnables";

const runnable1 = RunnableLambda.from((x: number) => {
return {
foo: x,
};
}).withConfig({
runName: "first",
});

async function* generatorFn(x: { foo: number }) {
for (let i = 0; i < x.foo; i++) {
yield i.toString();
}
}

const runnable2 = RunnableLambda.from(generatorFn).withConfig({
runName: "second",
});

const chain = runnable1.pipe(runnable2);

for await (const event of chain.streamEvents(2, { version: "v1" })) {
console.log(
`event=${event.event} | name=${event.name} | data=${JSON.stringify(
event.data
)}`
);
}
event=on_chain_start | name=RunnableSequence | data={"input":2}
event=on_chain_start | name=first | data={}
event=on_chain_stream | name=first | data={"chunk":{"foo":2}}
event=on_chain_start | name=second | data={}
event=on_chain_end | name=first | data={"input":2,"output":{"foo":2}}
event=on_chain_stream | name=second | data={"chunk":"0"}
event=on_chain_stream | name=RunnableSequence | data={"chunk":"0"}
event=on_chain_stream | name=second | data={"chunk":"1"}
event=on_chain_stream | name=RunnableSequence | data={"chunk":"1"}
event=on_chain_end | name=second | data={"output":"01"}
event=on_chain_end | name=RunnableSequence | data={"output":"01"}

Return a subset of keys from output object​

runnable.pick()​

import { RunnableLambda, RunnablePassthrough } from "@langchain/core/runnables";

const runnable = RunnableLambda.from((x: { baz: number }) => {
return x.baz + 5;
});

const chain = RunnablePassthrough.assign({
foo: runnable,
}).pick(["foo", "bar"]);

await chain.invoke({ bar: "hi", baz: 2 });
{ foo: 7, bar: "hi" }

Declaratively make a batched version of a runnable​

runnable.map()​

import { RunnableLambda } from "@langchain/core/runnables";

const runnable1 = RunnableLambda.from((x: number) => [...Array(x).keys()]);
const runnable2 = RunnableLambda.from((x: number) => x + 5);

const chain = runnable1.pipe(runnable2.map());

await chain.invoke(3);
[ 5, 6, 7 ]

Get a graph representation of a runnable​

runnable.getGraph()​

import { RunnableLambda, RunnableSequence } from "@langchain/core/runnables";

const runnable1 = RunnableLambda.from((x: any) => {
return { foo: x };
});

const runnable2 = RunnableLambda.from((x: any) => [x].concat([x]));

const runnable3 = RunnableLambda.from((x: any) => x.toString());

const chain = RunnableSequence.from([
runnable1,
{
second: runnable2,
third: runnable3,
},
]);

await chain.getGraph();
Graph {
nodes: {
"935c67df-7ae3-4853-9d26-579003c08407": {
id: "935c67df-7ae3-4853-9d26-579003c08407",
data: {
name: "RunnableLambdaInput",
schema: ZodAny {
spa: [Function: bound safeParseAsync] AsyncFunction,
_def: [Object],
parse: [Function: bound parse],
safeParse: [Function: bound safeParse],
parseAsync: [Function: bound parseAsync] AsyncFunction,
safeParseAsync: [Function: bound safeParseAsync] AsyncFunction,
refine: [Function: bound refine],
refinement: [Function: bound refinement],
superRefine: [Function: bound superRefine],
optional: [Function: bound optional],
nullable: [Function: bound nullable],
nullish: [Function: bound nullish],
array: [Function: bound array],
promise: [Function: bound promise],
or: [Function: bound or],
and: [Function: bound and],
transform: [Function: bound transform],
brand: [Function: bound brand],
default: [Function: bound default],
catch: [Function: bound catch],
describe: [Function: bound describe],
pipe: [Function: bound pipe],
readonly: [Function: bound readonly],
isNullable: [Function: bound isNullable],
isOptional: [Function: bound isOptional],
_any: true
}
}
},
"a73d7b3e-0ed7-46cf-b141-de64ea1e12de": {
id: "a73d7b3e-0ed7-46cf-b141-de64ea1e12de",
data: RunnableLambda {
lc_serializable: false,
lc_kwargs: { func: [Function (anonymous)] },
lc_runnable: true,
name: undefined,
lc_namespace: [ "langchain_core", "runnables" ],
func: [Function (anonymous)]
}
},
"ff104b34-c13b-4677-8b82-af70d3548e12": {
id: "ff104b34-c13b-4677-8b82-af70d3548e12",
data: RunnableMap {
lc_serializable: true,
lc_kwargs: { steps: [Object] },
lc_runnable: true,
name: undefined,
lc_namespace: [ "langchain_core", "runnables" ],
steps: { second: [RunnableLambda], third: [RunnableLambda] }
}
},
"2dc627dc-1c06-45b1-b14f-bb1f6e689f83": {
id: "2dc627dc-1c06-45b1-b14f-bb1f6e689f83",
data: {
name: "RunnableMapOutput",
schema: ZodAny {
spa: [Function: bound safeParseAsync] AsyncFunction,
_def: [Object],
parse: [Function: bound parse],
safeParse: [Function: bound safeParse],
parseAsync: [Function: bound parseAsync] AsyncFunction,
safeParseAsync: [Function: bound safeParseAsync] AsyncFunction,
refine: [Function: bound refine],
refinement: [Function: bound refinement],
superRefine: [Function: bound superRefine],
optional: [Function: bound optional],
nullable: [Function: bound nullable],
nullish: [Function: bound nullish],
array: [Function: bound array],
promise: [Function: bound promise],
or: [Function: bound or],
and: [Function: bound and],
transform: [Function: bound transform],
brand: [Function: bound brand],
default: [Function: bound default],
catch: [Function: bound catch],
describe: [Function: bound describe],
pipe: [Function: bound pipe],
readonly: [Function: bound readonly],
isNullable: [Function: bound isNullable],
isOptional: [Function: bound isOptional],
_any: true
}
}
}
},
edges: [
{
source: "935c67df-7ae3-4853-9d26-579003c08407",
target: "a73d7b3e-0ed7-46cf-b141-de64ea1e12de",
data: undefined
},
{
source: "ff104b34-c13b-4677-8b82-af70d3548e12",
target: "2dc627dc-1c06-45b1-b14f-bb1f6e689f83",
data: undefined
},
{
source: "a73d7b3e-0ed7-46cf-b141-de64ea1e12de",
target: "ff104b34-c13b-4677-8b82-af70d3548e12",
data: undefined
}
]
}

Was this page helpful?


You can also leave detailed feedback on GitHub.