Sign in to continue learning
Building Coding Agents with Tool Execution
Intermediate
1h21m
Topics
Agents
In this lesson, you will build your first coding agent from scratch. You'll give it real tools to execute code, read and write files and carry out multi-step reasoning loops. All right, let's get coding. Let's start by ignoring warnings with these two lines of code. All of the keys are set up for you on a DeepLearning.AI environment and you don't need to worry about it. Before we build our first agent, let's have a look at a more complex data analysis agent that you will build in the next... a taste of what you will be learning in this lesson. This agent is capable of running and executing code. So let's briefly just try one prompt to give you an idea of what we will be building. So let's ask, can you create me a function that draw an emoji and run it. On the right side, we see our context growing and we are using the same color scheme as in the slides, and the height is proportional to the token size. Here, the agent runs some code, it generates the code and runs it. looks like it's uh, yeah, it's making some Python code with matplotlib functions. but it's not really, it is not making a smiling emoji but for some reason a sad one, which is kind of interesting. And feel free to prompt it more and play with it as well. All right, back to our first coding agent. The first thing we need is a language model. For all of our lessons, we'll be using the OpenAI GPT models. We'll call the models by using a handy LLM function. taking an OpenAI client, a list of messages, a system prompt, and printing back the reply from the model. Next, we need to give our agent tools, actual function it can call to run things. Here we are defining a TypedDict that stores the results and errors, if any. Then the function execute_code runs whatever Python code is passed as a string. is using the exec built-in Python function to do so, and we also redirect standard output, so we can capture it and return it to us. Let's test it by printing Hello World. And we can see we have Hello World in our results key in the execution dictionary. In order for the agent to run this function, we need to describe it as a JSON schema. Note the name is execute_code and the parameters expect one property, code, as a string. We can register the tool by adding to the tools dictionary. Every tool we create later will go here as well. Next, we define a function called execute_tool. It takes the tool's name, finding the tools in a dictionary, pass the arguments and return the result. We also added some error handling in the case the agent had an error by parsing the arguments or calls a tool that does not exist. Now we can create our agent function. This is where the agent is going to live. We are passing the OpenAI client, an user query, system prompt, the tools registry, and the tools schemas. Similar to what we did at the beginning, we are creating the messages array. We are calling the LLM function with all the parameters, and we are iterating, through the response. If the part.type is message, it means that the model wants to speak back to us, so we're just printing the part.content. If the part.type is function_call, we are getting the function name, do some printing and use our execute_tool function to get the result from the tool. We can test it by making the agent generate some Python code and run it. Here we have a task-specific system prompt where we're telling the agent that is a Senior Python programmer, and we are also explaining how to use the tools. So here we're saying you must always use the execute_code tool to run code. Finally, we are telling how to collect user's inputs, just by using the input python function. Our task is straightforward. We want to make a program that asks us how many cups of coffee we had today, and then convert it back to lines of code. So, today I had a lot of coffee, actually. So let's go with five. And it looks like I wrote 215 lines of code because caffeine equal productivity. This is a full round trip. The agent received the user's query, reason about it, and decide which tool to call. A coding agent needs to use the file system to read, write, and edit files. Let's implement two tools to read and write files. First we need the read_file_schema. The name is read_file, is taking a file_path as a string of course, limit and offset. So how many characters and from where the agent is allowed to read from from the file. This is very important because we can have very big files and giving the model the ability to pick up how much characters it want to read can keep the context clean. The write_file_schema it's very similar. We are passing a content string and a file_path as well. Then we need to implement the actual function will be running when the agent wants to call. these two tools. Let's go ahead and implement the read_file function. Notice we are creating a custom exception. This is helpful because we can avoid passing long error stack traces and just create a specific concise error feedback back to the model. For example, if the file is not there, we are going to raise a new ToolError telling the model exactly that the file does not exist. Next, we implement the write_file function. Similar, we are also doing error handling in the same way as before. Finally, we can update our tools registry by adding these two new tools. Let's give it a test by creating a working dir, having a new user query in which we task the agent to create a blank text.txt file and telling where the working dir is supposed to be. Notice that we are passing our new tools_schemas to the coding_agent function. We can see the agent used our write_file tools and it has written zero bytes to that file. Let's now test our error handling. We can task the agent to read a file that is not there and see what happens. We can see it use the read_file tools again, but this time we got an error as a dictionary. And this time we got an error as a structured dictionary. This will help the agent recover and try again. So let's try to task the agent with something slightly more complicated. Here we want the agent to create a file with file one inside it and then read it back to us, as we were expecting, the agent is calling the write_file tool, writing five bytes to file one, and then the read_file tool. Then we can see that the content is actually file one. So far, our agent can just do one turn. But a real agent should iteratively perform tasks and stop when complete. We need to create a loop and exit conditions. The simplest way to decide when to stop is when the agent doesn't call new functions or reaches the maximum step limit. Let's go over the implementation. We are adding a new loop in the coding_agent function till a parameter max_steps is reached, defaults to five, and if the agent doesn't want to do a new function call, it means that it doesn't think it need to use the available tools. So we're going to label the task as completed. We are also keeping a list of messages and we are appending to it the initial user message, every message part, and the result from the tool. Let's test it out here. We want the model to create a Caesar cipher function, then we want it to ask me for a message, for the shift. Then we want to run it, print the ciphered message, and save it to a secret.txt file. So quite a lot of step that the agent will have to do. Super. I'm going to put my name, so Francesco. And I'm going to shift it by three letters, the alphabet. The message is this set of characters, and the model is telling me that it has written it to secret.txt file. I don't see any write_file tool, so probably it used Python to write to the file. So let's cat this file and see if it's really there. And we can see actually the agent wrote the right encrypted message to our folder. Let's create a simple interface to interact with our coding agent. We can test it out by asking the agent to create an ASCII cow and print it back to us. It worked and we can see our cow as ASCII art. Feel free to continue the conversation with your agent. The agent we just built in this lab is running code locally on the notebook. In the next lesson, you'll learn more about code execution environments and which one is the best, depending on the use case.
