การปรับแต่งตรรกะของเชน

In previous lessons, you learned how to create sequential chains to perform multi-step operations. These chains are powerful for connecting standard LangChain components like prompts and LLMs.

But what if you need to do something unique? What if you need to process data in a specific way before it reaches your LLM, or format its output afterward?

Standard chains are great, but they can't handle every scenario. Custom logic allows you to:

• Pre-process inputs: Clean, validate, or transform user input before sending it to a prompt or LLM.
• Post-process outputs: Parse, filter, or reformat LLM responses for display or further use.
• Integrate external logic: Call your own Python functions, external APIs, or apply conditional routing.
• Handle complex data transformations: Convert data types, merge information, or apply business rules.

LangChain's RunnableLambda is your key to integrating custom Python functions into chains. It wraps any Python callable (like a function or a lambda expression) and makes it behave like a LangChain Runnable component.

This means you can seamlessly insert your own Python logic anywhere in a chain, just like you would an LLM or a prompt template!

Let's start with a simple custom function that adds an exclamation mark to a string. We'll wrap it with RunnableLambda to make it part of a chain.

Try running this basic example:

The real power comes when you combine RunnableLambda with other LangChain components. You can place your custom logic at the beginning, middle, or end of a chain.

For example, you might have a custom function that prepares the input for a prompt, or one that processes the output from an LLM.

Here's an example where a custom step pre-processes the input by converting it to uppercase before it's passed to a PromptTemplate and then to a simulated LLM.

Notice how the `uppercase_input` function expects a dictionary, mirroring how chain inputs often work.

Just as you can pre-process inputs, you can also post-process the outputs from an LLM. This is useful for:

• Extracting specific information from a longer response.
• Formatting the output for display in a UI.
• Converting the output to a different data structure (e.g., JSON).
• Adding a custom header or footer to the LLM's message.

Let's create a custom function that takes the raw LLM response and wraps it with a friendly message. This makes the output more user-friendly.

Run this example to see the LLM's response being transformed:

RunnableLambda isn't just for simple transformations. You can embed complex Python logic, including conditionals, loops, and even calls to other services, directly into your chain.

For instance, you could have a custom step that checks if an input meets certain criteria and, if not, redirects the flow or returns a default message, creating dynamic and intelligent workflows.

Which of the following are good use cases for integrating custom Python logic (e.g., using RunnableLambda) into a LangChain workflow?

You've learned how to inject your own Python functions and logic into LangChain workflows using RunnableLambda. This powerful feature allows you to:

• Perform custom pre-processing on inputs.
• Apply custom post-processing to LLM outputs.
• Integrate complex or conditional logic within your chains.

By mastering custom chain logic, you gain immense flexibility to tailor LangChain to your exact needs, building truly unique and intelligent applications. Next, explore how to use pre-built toolkits to add even more capabilities to your agents!