自定义链逻辑
了解如何构建自定义链，并在 LangChain 工作流中集成您自己的 Python 函数和逻辑
自定义链逻辑 是 CoddyKit 上的免费 AI Agents with LangChain & Autonomous Workflows 课时。 这是第 3 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 AI Agents with LangChain & Autonomous Workflows 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 AI Agents with LangChain & Autonomous Workflows 课程共包含 4 节课。
本课时的部分内容尚未翻译，以英文显示。
Beyond Standard Chains
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?
When to Add Custom Steps
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.
Introducing RunnableLambda
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!
Your First Custom Function
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:
from langchain_core.runnables import RunnableLambda
def add_exclamation(text: str) -> str:
return text + "!"
if __name__ == "__main__":
# Wrap your function to make it a Runnable
custom_step = RunnableLambda(add_exclamation)
# Invoke it like any other Runnable
result = custom_step.invoke("Hello CoddyKit")
print(result)Chaining Custom Logic
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.
Custom Pre-processing Chain
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.
from langchain_core.prompts import PromptTemplate
from langchain_core.runnables import RunnableLambda
from langchain_community.llms import FakeListLLM
def uppercase_input(data: dict) -> dict:
# Ensure 'text' key exists and convert its value to uppercase
return {"text": data.get("text", "").upper()}
if __name__ == "__main__":
# A simulated LLM for demonstration
llm = FakeListLLM(responses=["I received your uppercase text!"])
# Define a simple prompt template
prompt = PromptTemplate.from_template(
"You mentioned: {text}. What do you think?"
)
# Create the custom pre-processing step
pre_process_step = RunnableLambda(uppercase_input)
# Build the chain: custom_step -> prompt -> llm
custom_chain = pre_process_step | prompt | llm
# Invoke the chain with lowercase input
input_data = {"text": "hello world"}
response = custom_chain.invoke(input_data)
print(response)Custom Post-processing Logic
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.
Example: Custom Output Formatting
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:
from langchain_core.runnables import RunnableLambda
from langchain_community.llms import FakeListLLM
def format_llm_output(llm_response: str) -> str:
# Add a custom prefix and suffix to the LLM's message
return f"🤖 AI says: '{llm_response.strip()}' - Over and out!"
if __name__ == "__main__":
# A simulated LLM for demonstration
llm = FakeListLLM(responses=["The weather is sunny today."])
# Create the custom post-processing step
post_process_step = RunnableLambda(format_llm_output)
# Build the chain: llm -> custom_step
custom_chain = llm | post_process_step
# Invoke the chain (input doesn't affect FakeListLLM's response here)
response = custom_chain.invoke("What's the weather like?")
print(response)Adding Conditional Logic
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.
Quick Check: Custom Chain Steps
Which of the following are good use cases for integrating custom Python logic (e.g., using RunnableLambda) into a LangChain workflow?
Recap & Next Steps
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!
常见问题解答
「自定义链逻辑」课时是免费的吗？
是的 — 「自定义链逻辑」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 AI Agents with LangChain & Autonomous Workflows 课程的其余内容，请升级到 CoddyKit PRO。 AI Agents with LangChain & Autonomous Workflows 课程共包含 4 节课。
「自定义链逻辑」这节课中我会学到什么？
了解如何构建自定义链，并在 LangChain 工作流中集成您自己的 Python 函数和逻辑 你通过在浏览器中直接运行的动手代码来练习 AI Agents with LangChain & Autonomous Workflows，全天候 AI 导师会在你学习这节课的过程中回答你的问题。
学习 AI Agents with LangChain & Autonomous Workflows 需要有经验吗？
无需任何先前经验。CoddyKit 上的 AI Agents with LangChain & Autonomous Workflows 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 3 节课，共 4 节。
「自定义链逻辑」课时需要多长时间？
大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。
我能在这节 AI Agents with LangChain & Autonomous Workflows 课中编写并运行代码吗？
能。每节 AI Agents with LangChain & Autonomous Workflows 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。