<div id="readability-page-1" class="page"><div>This example shows how to add code interpreting to an LLM using the <a href="https://github.com/e2b-dev/code-interpreter" target="_blank" rel="noopener noreferrer" data-external="true">Code Interpreter SDK</a> and <a href="https://langchain-ai.github.io/langgraph/" target="_blank" rel="noopener noreferrer" data-external="true">LangGraph</a>.
🔗 <a href="https://github.com/e2b-dev/e2b-cookbook/tree/main/examples/langgraph-python" target="_blank" rel="noopener noreferrer" data-external="true">Full code on GitHub</a>
<h2 id="why-code-interpreter-sdk">Why Code Interpreter SDK</h2>
The <a href="https://github.com/e2b-dev/code-interpreter" target="_blank" rel="noopener noreferrer" data-external="true">E2B Code Interpreter SDK</a> quickly creates a secure cloud sandbox powered by <a href="https://github.com/firecracker-microvm/firecracker" target="_blank" rel="noopener noreferrer" data-external="true">Firecracker</a>. Inside this sandbox is a running Jupyter server that the LLM can use.
In general, the Code Interpreter SDK allows you to build custom code interpreters. For example, you can <a href="https://docs.e2b.dev/template/quickstart" target="_blank" rel="noopener noreferrer" data-external="true">install custom packages</a>, have access to the internet, <a href="https://docs.e2b.dev/filesystem" target="_blank" rel="noopener noreferrer" data-external="true">use the filesystem</a>, or <a href="https://docs.e2b.dev/storage/cloud-buckets" target="_blank" rel="noopener noreferrer" data-external="true">connect your cloud storage</a>.
The Code Interpreter SDK works with <a href="https://github.com/e2b-dev/e2b-cookbook/tree/main" target="_blank" rel="noopener noreferrer" data-external="true">any LLM</a>, in this example, we are using OpenAI's <a href="https://platform.openai.com/docs/models/gpt-3.5-turbo" target="_blank" rel="noopener noreferrer" data-external="true">GPT-3.5 Turbo</a> to plot a sine wave.
<figure></figure>
<h3 id="key-links">Key links</h3>

<h3 id="overview">Overview</h3>
<ol>
<li>Install dependencies</li>
<li>Get API keys, prompt, and tools</li>
<li>Implement the method for code interpreting</li>
<li>Implement the methods for calling tool, create workflow and invoke the LangGraph app</li>
<li>Run the program</li>
</ol>
<h2 id="setup">Setup</h2>
<h3 id="1-install-dependencies">1. Install dependencies</h3>
We start by installing the <a href="https://github.com/e2b-dev/code-interpreter" target="_blank" rel="noopener noreferrer" data-external="true">E2B code interpreter SDK</a> and <a href="https://console.groq.com/" target="_blank" rel="noopener noreferrer" data-external="true">LangChain Python SDK</a>.
<figure><div><pre tabindex="0"><code>pip install langgraph e2b-code-interpreter langchain langchainhub langchain-openai</code></pre></div></figure>
<h3 id="2-define-api-keys-prompt-and-tools">2. Define API keys, prompt, and tools</h3>
Now we store your the <a href="https://docs.e2b.dev/api-key" target="_blank" rel="noopener noreferrer" data-external="true">E2B API KEY</a> and <a href="https://platform.openai.com/settings" target="_blank" rel="noopener noreferrer" data-external="true">OPENAI API KEY</a>.
<figure><div><pre tabindex="0"><code>import os

# TODO: Get your OpenAI API key from https://platform.openai.com/api-keys
os.environ["OPENAI_API_KEY"] = ""

# TODO: Get your E2B API key from https://docs.e2b.dev
os.environ["E2B_API_KEY"] = ""</code></pre></div></figure>
<h3 id="3-implement-the-method-for-code-interpreting">3. Implement the method for code interpreting</h3>
This part includes the tool definition that uses the <a href="https://github.com/e2b-dev/code-interpreter" target="_blank" rel="noopener noreferrer" data-external="true">E2B Code Interpreter SDK</a>. We'll be using this to get the E2B code interpreter tool and to format the output of the tool.
First, we import all necessary libraries.
<figure><div><pre tabindex="0"><code>import os
import json

from typing import Any
from langchain_core.tools import Tool
from pydantic.v1 import BaseModel, Field
from e2b_code_interpreter import CodeInterpreter
from langchain_core.messages import ToolMessage</code></pre></div></figure>
Then we define classes to allow the LLM use a code interpreter as a tool. The class <code>LangchainCodeInterpreterToolInput</code> defines the input schema for the tool using <a href="https://docs.pydantic.dev/latest/" target="_blank" rel="noopener noreferrer" data-external="true">Pydantic</a>, specifying that the input will be a string of Python code.
The class <code>CodeInterpreterFunctionTool</code> calls arbitrary code against a Python Jupyter notebook. It requires an <code>E2B_API_KEY</code> to create a sandbox.
We define the <code>format_to_tool_messages</code> function to identify for each agent's action whether it corresponds to a specific tool.
<figure><div><pre tabindex="0"><code>class RichToolMessage(ToolMessage):
 raw_output: dict


class LangchainCodeInterpreterToolInput(BaseModel):
 code: str = Field(description="Python code to execute.")


class CodeInterpreterFunctionTool:
 tool_name: str = "code_interpreter"

 def __init__(self):
 # Instantiate the E2B sandbox - this is a long lived object
 # that's pinging E2B cloud to keep the sandbox alive.
 if "E2B_API_KEY" not in os.environ:
 raise Exception(
 "Code Interpreter tool called while E2B_API_KEY environment variable is not set. Please get your E2B api key here https://docs.e2b.dev and set the E2B_API_KEY environment variable."
 )
 self.code_interpreter = CodeInterpreter()

 def close(self):
 self.code_interpreter.close()

 def call(self, parameters: dict, **kwargs: Any):
 code = parameters.get("code", "")
 print(f"***Code Interpreting...\n{code}\n====")
 execution = self.code_interpreter.notebook.exec_cell(code)
 return {
 "results": execution.results,
 "stdout": execution.logs.stdout,
 "stderr": execution.logs.stderr,
 "error": execution.error,
 }

 # langchain does not return a dict as a parameter, only a code string
 def langchain_call(self, code: str):
 return self.call({"code": code})

 def to_langchain_tool(self) -&gt; Tool:
 tool = Tool(
 name=self.tool_name,
 description="Execute python code in a Jupyter notebook cell and returns any rich data (eg charts), stdout, stderr, and error.",
 func=self.langchain_call,
 )
 tool.args_schema = LangchainCodeInterpreterToolInput
 return tool

 @staticmethod
 def format_to_tool_message(
 tool_call_id: str,
 output: dict,
 ) -&gt; RichToolMessage:
 """
 Format the output of the CodeInterpreter tool to be returned as a RichToolMessage.
 """

 # TODO: Add info about the results for the LLM
 content = json.dumps(
 {k: v for k, v in output.items() if k not in ("results")}, indent=2
 )

 return RichToolMessage(
 content=content,
 raw_output=output,
 tool_call_id=tool_call_id,
 )</code></pre></div></figure>
<h3 id="4-implement-the-methods-for-calling-tool-create-workflow-and-invoke-the-langgraph-app">4. Implement the methods for calling tool, create workflow and invoke the LangGraph app</h3>
Now we define the <code>format_to_tool_messages</code> function to identify for each agent's action whether it corresponds to a specific tool. If it does, the function formats the action and observation into messages and appends them to the <code>messages</code> list, ensuring no duplicates.
We create a prompt template that will be used by the agent to generate responses. We define and invoke the agent, during which we specify the prompt, which is to plot and show sinus.
<figure><div><pre tabindex="0"><code>from typing import List
from langchain_openai import ChatOpenAI
from langgraph.graph import END, MessageGraph


# Define the function that determines whether to continue or not
def should_continue(messages) -&gt; str:
 last_message = messages[-1]
 # If there is no function call, then we finish
 if not last_message.tool_calls:
 return END
 else:
 return "action"


# Handle tools execution
def execute_tools(messages, tool_map) -&gt; List[RichToolMessage]:
 tool_messages = []
 for tool_call in messages[-1].tool_calls:
 tool = tool_map[tool_call["name"]]
 if tool_call["name"] == CodeInterpreterFunctionTool.tool_name:
 output = tool.invoke(tool_call["args"])
 message = CodeInterpreterFunctionTool.format_to_tool_message(
 tool_call["id"],
 output,
 )
 tool_messages.append(message)
 else:
 content = tool.invoke(tool_call["args"])
 tool_messages.append(RichToolMessage(content, tool_call_id=tool_call["id"]))
 return tool_messages

# 1. Pick your favorite llm
llm = ChatOpenAI(model="gpt-3.5-turbo-0125", temperature=0)

# 2. Initialize the code interpreter tool
code_interpreter = CodeInterpreterFunctionTool()
code_interpreter_tool = code_interpreter.to_langchain_tool()
tools = [code_interpreter_tool]
tool_map = {tool.name: tool for tool in tools}

# 3. Define the graph
workflow = MessageGraph()
workflow.add_node("agent", llm.bind_tools(tools))
workflow.add_node("action", lambda x: execute_tools(x, tool_map))

# Conditional agent -&gt; action OR agent -&gt; END
workflow.add_conditional_edges(
 "agent",
 should_continue,
)
# Always transition `action` -&gt; `agent`
workflow.add_edge("action", "agent")

workflow.set_entry_point("agent")

app = workflow.compile()

# 4. Invoke the app
result = app.invoke([("human", "plot and show sinus")])

code_interpreter.close()

def display_results(messages):
 for message in result:
 if hasattr(message, 'raw_output'):
 if message.raw_output["results"]:
 rs = message.raw_output["results"]
 for r in rs:
 display(r)

display_results(result)</code></pre></div></figure>
<h3 id="5-run-the-program">5. Run the program</h3>
Finally, we run the program. The task given to the agent was to plot and show a sine function.
<figure><div><pre tabindex="0"><code>***Code Interpreting...
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 2*np.pi, 100)
y = np.sin(x)

plt.plot(x, y)
plt.title('Sine Wave')
plt.xlabel('x')
plt.ylabel('sin(x)')
plt.grid(True)
plt.show()
====</code></pre></div></figure>
<figure></figure>
🔗 <a href="https://github.com/e2b-dev/e2b-cookbook/tree/main/examples/langgraph-python" target="_blank" rel="noopener noreferrer" data-external="true">Full code on GitHub</a>
<h3 id="key-links-1">Key links</h3>
</div></div>

E2B Blog & Customer Stories

Vaclav Mlejnsky

This example shows how to add code interpreting to an LLM using the Code Interpreter SDK and LangGraph.

Give LangGraph code execution capabilities

댓글