<div id="readability-page-1" class="page"><div>In this guide, we will show how to upload your own CSV file for an AI assistant to analyze. The assistant is powered by <a href="https://ai.meta.com/blog/meta-llama-3/" target="_blank" rel="noopener noreferrer" data-external="true">Meta's Llama 3</a> and executes its actions in the secure sandboxed environment via the <a href="https://github.com/e2b-dev/code-interpreter" target="_blank" rel="noopener noreferrer" data-external="true">E2B Code Interpreter SDK</a>.
🔗 <a href="https://github.com/e2b-dev/e2b-cookbook/blob/main/examples/upload-dataset-code-interpreter/upload_dataset.ipynb" 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>.
<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 method for calling LLM and parsing tools</li>
<li>Implement method for uploading dataset to code interpreter sandbox</li>
<li>Put everything together</li>
</ol>
<h2 id="setup">Setup</h2>
<h3 id="1-install-dependencies">1. Install dependencies</h3>
First, we install 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">Groq's Python SDK</a>.
<figure><div><pre tabindex="0"><code>pip install groq e2b_code_interpreter</code></pre></div></figure>
<h3 id="2-get-api-keys-prompt-and-tools">2. Get API keys, prompt, and tools</h3>
Then we store the <a href="https://console.groq.com/" target="_blank" rel="noopener noreferrer" data-external="true">Groq</a> and <a href="https://docs.e2b.dev/" target="_blank" rel="noopener noreferrer" data-external="true">E2B</a> API keys and set the model name for the Llama 3 instance we will use. In the system prompt we define the rules for the interaction with Llama. We define our tools - there will be just one tool for executing Python code.
<figure><div><pre tabindex="0"><code># TODO: Get your Groq AI API key from https://console.groq.com/
GROQ_API_KEY = ""

# TODO: Get your E2B API key from https://docs.e2b.dev
E2B_API_KEY = ""

# Or use 8b version
# MODEL_NAME = "llama3-8b-8192"
MODEL_NAME = "llama3-70b-8192"

SYSTEM_PROMPT = """You're a Python data scientist that is analyzing daily temperature of major cities. You are given tasks to complete and you run python code to solve them.

Information about the the temperature dataset:
- It's in the `/home/user/city_temperature.csv` file
- It has following columns (examples included):
 - `Region`: "North America", "Europe"
 - `Country`: "Iceland"
 - `State`: for example "Texas" but can also be null
 - `City`: "Prague"
 - `Month`: "June"
 - `Day`: 1-31
 - `Year`: 2002
 - `AvgTemperature`: temperature in celsiu, for example 24

Generally you follow these rules:
- the python code runs in jupyter notebook.
- every time you call `execute_python` tool, the python code is executed in a separate cell. it's okay to multiple calls to `execute_python`.
- display visualizations using matplotlib or any other visualization library directly in the notebook. don't worry about saving the visualizations to a file.
- you have access to the internet and can make api requests.
- you also have access to the filesystem and can read/write files.
- you can install any pip package (if it exists) if you need to but the usual packages for data analysis are already preinstalled.
- you can run any python code you want, everything is running in a secure sandbox environment
"""


tools = [
 {
 "type": "function",
 "function": {
 "name": "execute_python",
 "description": "Execute python code in a Jupyter notebook cell and returns any result, stdout, stderr, display_data, and error.",
 "parameters": {
 "type": "object",
 "properties": {
 "code": {
 "type": "string",
 "description": "The python code to execute in a single cell.",
 }
 },
 "required": ["code"],
 },
 },
 }
]</code></pre></div></figure>
<h3 id="3-implement-the-method-for-code-interpreting">3. Implement the method for code interpreting</h3>
We define the main function that uses the E2B code interpreter to execute code in a Jupyter Notebook that's running inside the E2B sandbox. We'll be calling this function a little bit further when we're parsing the Llama's response with tool calls.
<figure><div><pre tabindex="0"><code>def code_interpret(e2b_code_interpreter, code):
 print("Running code interpreter...")
 exec = e2b_code_interpreter.notebook.exec_cell(
 code,
 on_stderr=lambda stderr: print("[Code Interpreter]", stderr),
 on_stdout=lambda stdout: print("[Code Interpreter]", stdout),
 # You can also stream code execution results
 # on_result=...
 )

 if exec.error:
 print("[Code Interpreter ERROR]", exec.error)
 else:
 return exec.results</code></pre></div></figure>
<h3 id="4-implement-the-method-for-calling-llm-and-parsing-tools">4. Implement the method for calling LLM and parsing tools</h3>
Now we're going to define and implement <code>chat_with_llama</code> method. In this method, we'll call the LLM with our <code>tools</code> dictionary, parse the output, and call our <code>code_interpret</code> method we defined above.
See the <a href="https://wow.groq.com/docs/" target="_blank" rel="noopener noreferrer" data-external="true">Groq documentation</a> to get started.
<figure><div><pre tabindex="0"><code>import os
import json
import re
from groq import Groq

client = Groq(api_key=GROQ_API_KEY)

def chat_with_llama(e2b_code_interpreter, user_message):
 print(f"\n{'='*50}\nUser message: {user_message}\n{'='*50}")

 messages = [
 {"role": "system", "content": SYSTEM_PROMPT},
 {"role": "user", "content": user_message}
 ]

 response = client.chat.completions.create(
 model=MODEL_NAME,
 messages=messages,
 tools=tools,
 tool_choice="auto",
 max_tokens=4096,
 )

 response_message = response.choices[0].message
 tool_calls = response_message.tool_calls

 if tool_calls:
 for tool_call in tool_calls:
 function_name = tool_call.function.name
 function_args = json.loads(tool_call.function.arguments)
 if function_name == "execute_python":
 code = function_args["code"]
 code_interpreter_results = code_interpret(e2b_code_interpreter, code)
 return code_interpreter_results
 else:
 raise Exception(f"Unknown tool {function_name}")
 else:
 print(f"(No tool call in model's response) {response_message}")
 return []</code></pre></div></figure>
<h3 id="5-implement-method-for-uploading-dataset-to-code-interpreter-sandbox">5. Implement method for uploading dataset to code interpreter sandbox</h3>
The file gets uploaded to the E2B sandbox where our code interpreter is running. We get the file's remote path in the <code>remote_path</code> variable.
<figure><div><pre tabindex="0"><code>def upload_dataset(code_interpreter):
 print("Uploading dataset to Code Interpreter sandbox...")
 with open("./city_temperature.csv", "rb") as f:
 remote_path = code_interpreter.upload_file(f)
 print("Uploaded at", remote_path)</code></pre></div></figure>
<h3 id="6-put-everything-together">6. Put everything together</h3>
Finally, we put all the pieces together. We instantiate a new code interpreter instance using
<code>with CodeInterpreter(api_key</code>=<code>E2B_API_KEY) as code_interpreter:</code>
and then call the <code>chat_with_llama</code> method with our user message and the <code>code_interpreter</code> instance.
<figure><div><pre tabindex="0"><code>from e2b_code_interpreter import CodeInterpreter


with CodeInterpreter(api_key=E2B_API_KEY) as code_interpreter:

 # Upload the dataset to the code interpreter sandbox
 upload_dataset(code_interpreter)

 code_results = chat_with_llama(
 code_interpreter,
 "Plot average temperature over the years in Algeria"
 )
 if code_results:
 first_result = code_results[0]
 else:
 raise Exception("No code results")


# This will render the image
# You can also access the data directly
# first_result.png
# first_result.jpg
# first_result.pdf
# ...
first_result</code></pre></div></figure>
<figure><div><pre tabindex="0"><code>Uploading dataset to Code Interpreter sandbox...
Uploaded at /home/user/city_temperature.csv

==================================================
User message: Plot average temperature over the years in Algeria
==================================================
Running code interpreter...</code></pre></div></figure>
<figure></figure>
🔗 <a href="https://github.com/e2b-dev/e2b-cookbook/blob/main/examples/upload-dataset-code-interpreter/upload_dataset.ipynb" 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

Follow these steps to use Llama 3, Groq, and E2B for analyzing your uploaded data files

How to analyze your CSV files with Llama 3

댓글