AI is single-handedly making this decade one that is going to go down in history. At this point, that isn't even up for debate. One huge part of that is AI agents, which are large language models that are able to interact with the outside world through APIs, web scraping, code generation, and the list goes on. There are a million different ways to build AI agents, both with code and no-code solutions, and there are really good arguments to go both ways. On the one hand, no-code solutions like Flowise and n8n make it so incredibly easy to build powerful AI agents without having to debug and maintain a bunch of code. On the other hand, coding your own AI agents with languages like Python and libraries like LangChain gives you all the customization and control you could possibly need, and sometimes no-code tools just don't offer that. A lot of times, you have to code your own AI agents for production because no-code solutions oftentimes aren't feature-rich enough when your requirements start to get really specific, and so a lot of

times people will start with no code and then move away from it out of necessity. However, I have actually found the perfect trifecta that actually combines code and no code to give you the best of both worlds: quick and easy to develop AI agents that are still extremely powerful and able to meet any of your needs. What's the secret here? It's using n8n for the Asian tools and then python plus Lang chain for the AI agent itself. I am obsessed with this combination because it really does leverage the strengths of code and no code so well. All right, just hear me out on this: n8n makes it so easy to set up credentials for your services and then connect them all together in workflows that you can actually create as API endpoints for your agents. And then python plus Lang chain allows you to create AI agents really easily with any LLM that you choose and very few lines of code. And then you can hook into your N8 end workflows in like five lines of code and then create custom tools in

Python for anything that maybe you couldn't do in n8n, so it is just the perfect combination. And if you can't see the beauty of it at this point, I don't know what to tell you. So I'm going to walk you step by step through how to set up this kind of agent with a fun and practical example that I've created for you, and we'll even test it out at the end to see how well it does. My goal by the end of this video is to have you convinced that this is the way to build your AI agents. All right, so since we are combining code and no code for this AI agent, there's going to be two main parts to what I'm walking through here. First is going to be the n8n workflows that give us the tools to interact with services like Slack and Google Drive, and then in the second half, I'll walk you through coding the agent with Python and LangChain and actually integrating with the n8n workflows to bring everything together. So what this AI

agent is going to be able to do is send messages in Slack, summarize conversations in Slack, and upload files to Google Drive. Just a few simple example tools that I put together here for this agent to make something simple and still pretty practical. But what I really want to drive across here as the main point is that you can extend this to anything because the sky is the limit with what workflows you can create in n8n and integrate into this agent. And so just think of what you want to make, and then as I'm walking you through this, think about how you could so easily just do that with what I'm setting up here. So the first thing I want to do is quickly walk you through the three n8n workflows that I'll be using for tools for our AI agent that we're making with Python and Langchain. Now, I'm not going to cover how to set up n8n or how to set up each of these workflows in great detail because the main thing that I want to cover here is how exactly you

can use NN workflows as tools in a Python plus Lang chain agent. I don't want to spend all the time boring you with the details of setting up these workflows right now, but I have a lot of other videos on my channel, and there are a lot of other resources on YouTube for actually setting up NN and getting into the nitty-gritty details of making these workflows. And so again, this is just going to be a high-level overview, but I want to show you what we are actually doing for these tools. So the first tool that I have here is one to summarize a Slack conversation. And so it starts with a webhook because there's going to be a URL that we invoke within our Python code to make this tool call. And with this request here, it's going to go in to basically just pull a bunch of Slack messages from a specific channel that I have referenced here. And you could make this dynamic if you were to extend the agent and have it actually look up channel IDs and then pass one in to

fetch messages from a specific channel, but just to keep it simple here, I have the channel hardcoded. And so, going over to this little test Slack workspace that I have created here, this is what I have for my demo here. So, I just have this little conversation that I made with myself as an example. It's just somebody that is planning a new startup for AI pets, and they're trying to figure out their tech stack. So, this is what I've got for a little nine-message conversation here, something that we'll be summarizing. And so, I pull all those messages, I aggregate them all together into a single field, and then I can pass that into my large language model with a prompt telling it to summarize this conversation. So, I dynamically pass in the combined list of messages from Slack, telling the LLM to summarize it. And then, for my model here, I'm just going to be using GPT-4 Mini. And then, once I get that response from the LLM with the summary, I respond to the webhook with that item. And so, now I'm going back to

the python code with that summarization, and then my agent can do whatever it wants to do with that summary. So, that is the first tool that we have here for slack. The next tool that I want to cover really quickly here is the one to post a message to slack. Now, this one is even simpler than the other one because there's really just one action that we want to do here to make the message in slack. And so, of course, we want to start and end with the web host again because we want to again call this URL within our python code to invoke this tool to send a message to slack. And so, within our python code, we'll have a function that'll accept an argument of the message text to send, and then it'll invoke this web hook with that as part of the payload so that we have the text we actually want to send into the slack Channel. And so, we have that dynamically referenced here and the message text attribute of this node to send a slack message. Again, I have the channel.

hardcoded here. You could make this dynamic if you want with another tool to look up channel IDs in the Slack workspace, but I'm just keeping it simple here. The other thing that I wanted to quickly mention here, just like a really neat little golden nugget to save you some time setting up the Slack credentials, is a little bit trickier in n8n than some of the other credentials. It's still easy overall because n8n makes it super clean to do everything. It provides you documentation, but keep in mind that when you go into their documentation for setting up the credentials, they reference the navigation in kind of a strange way that didn't quite make sense to me. So let me find this here. Yeah, so it'll tell you to go to add features and functionality and select permissions. That doesn't seem to actually exist if you go into api.slack.com, where you need to go to set up your Slack app to get the credentials to put into n8n to get to permissions. You actually want to

go to ooth and permissions. So once you are there, that's where you'll see the redirect URL that n8n asks from you to get from Slack. And then also for the Scopes. Here, let me just scroll on the bottom. I was playing around with a lot here. When it tells you it needs certain Scopes, you'll run the workflow, and you'll get errors when those Scopes aren't set up. But in your user token Scopes here, you can just set. These are the ones that you typically will need to actually read messages. So when you're summarizing the conversation with that other workflow, these are the ones you need. And then I think there might be some other ones you have to set up for sending messages. But anyway, this is where you do all of that. So just keep that in mind, just a little bit of a golden nugget for you there. So back to the workflow here, I've got my credential set up already, of course. And then yeah, just the last thing, respond to the webhook.

with that incoming item, so basically the result of sending the Slack message. So the third and final tool that we have here is for creating a file in Google Drive, specifically a Google Doc. Now, this tool is really simple, just like the last one, a single action that we have here to create a file in Google Drive. So we have a couple of parameters that are coming in from the API call, which is basically just the name of the file and the text to put in it. And then I'm hardcoding the folder that I'm going to upload to Google Drive, just to this meeting notes folder that I've kind of been playing around with with other videos on my channel. And then lastly, one really important thing is in the extra options here, I added this toggle to convert to a Google Document. Otherwise, the text that I upload to Google Drive will just be put in a raw .txt file, and I like Google Docs. I just want it to look really nice, and so that's why I did that. And so then everything else with the web hooks is

exactly the same, and that is this workflow. You can see here how once you kind of get it down with how the webhooks work and what actions you want in the N workflows, it is so, so easy to set up any tool that you want for your Python and Lang chain code. And speaking of that, we can dive into that now and actually start using these workflows for our agent. Now for my favorite part, we get to code the AI agent with Python and Lang chain and interact with our n8n workflows. Really quick before I get started, I'm going to have a link in the description of this video to a GitHub repository where you can find all of the code that we're about to create here if you want to quickly snag that for yourself and implement it. But right now, I'm going to walk you through step by step creating all of this code for interacting with n8n, building our AI agent, all that good stuff. You can see right here I just had the skeleton for a main function in my main Python script.

and then I have this other blank python script where we'll be creating all the tools to interact with the n8n API endpoints. Also, with all the code in the GitHub repository, there is also a requirements.txt file so you can see the python packages and their versions to have the exact same environment as me. And then also an env.example file that you fill out with your own credentials, like things for your anthropic or open API Keys, all of your production NN webhook URLs that we went over earlier. And then also when you set up the authorization on your NN webhooks, you're going to have a ER token. I have instructions on how to create that as well within n8n. You're going to want to get all that set up in here, rename this file to .env, and then you'll be set up with the exact same environment as me. So now we can actually create our agent tools that will interact with our n8n API endpoints, and I'll start within this utility python script for defining the

tools by importing all the packages that I need, things like EnV, and then also the tool utility from Lang chain, which is a function decorator that actually makes it so that functions we define here can be used as tools that we bind into our agent. Next up, I'm going to load the environment variables and then bring in everything that I need for n8n, including that Bearer token that'll have as my authorization header. You set that up in n8n, and then also the three production URLs that we need here to call each of the web hooks for those different n8n workflows. Next up, I have a little helper function here, and this is probably the neatest part of this whole setup because it makes it very easy to create as many tools as you possibly want because all of them are going to leverage this function that makes it super clean to make these API requests to the n8n workflows. And so, the first thing that I do here is I have all my parameters defined, things like the method, which is

either going to be a GET or a POST depending on the type of operation, the URL, which is the n8n workflow URL, and then the function name because this is going to basically be how the AI knows which tool it's actually invoking, and then optionally a payload like if you have to pass in something like the message you want to send in Slack, the actual text for that, and so with that, we'll define our headers, which includes our Bearer token that we need, otherwise n8n will reject this API call, and then we can try to make this request, and so this supports both GET requests and POST requests with a payload. We have both between our different workloads that we have in n8n, and then if we get a success call to the API endpoint, we will raise for status in case there's like a forbidden 403 error, and then we'll return the response from the API endpoint so the agent can reason about what happened when it actually called this tool, and then we'll have an accept.

here basically just if there's any error at all, we'll just catch it and then return back to the agent telling it that there was an error with this specific function. Here's what the error was so that it can try to correct itself and maybe call the tool again. So that is everything that we need now, this neat little wrapper function that makes it so easy to set up any tools working with NN. You'll see that right now, um, and so we'll go ahead and start defining these tools. And so the first one that we want right here is the tool to summarize a slack conversation. And when you use the tool decorator here, so you put @tool at the top of your function, that's Lang Chain's way of turning this function into a tool package. And so we're going to get all of our different tools together, together combine them, put them into the large language model, and the large language model is actually going to use the doc strings here to understand when to use these functions and how to use them. So I give a little

description. I give an example call, and then I specify any arguments and also what this function will return so that it can reason about the output. Like maybe when I summarize a Slack conversation, I obviously return the summary, and so I tell the AI that it can expect to get the summary back, which also helps it know when to invoke this tool specifically. And look at how simple this function is. It is literally just five lines of code here because I return. Calling this function right here, this helper function that I made specifically, it is a GET request. I have this environment variable that defines my exact n8n API URL, and then I have the name of the function as well. It is that easy. And for the other two tools, it is also just as easy. So we have one to send a Slack message. Again, docstring to help but understand when and how to use this tool. It's a POST request. I've got this URL, and then my payload is going to include the message that I want to send in Slack. And so that's the one parameter.

that I have for this tool, and I tell the large language model in the doc string exactly what this parameter needs to be so that it knows what to pass in for the message for sending a slack message. And so that my very last tool that I have here is creating a Google doc. And so this time I accept two parameters because I need the name of the file and the text within it. And again, I just call invoke N8 and wook. It is so, so easy. So even if I had 20 tools for this agent, this file wouldn't be that much bigger. It takes more space to write the doc string than it actually does to create any of these tools because I'm really leveraging n8n for most of the complexity for the actions that I want to do here. And that's the beauty of it. There's not actually that much code because I'm leveraging no code to make things that much simpler. And if I really need extra complexity for a tool that n8n can't support, then I could custom

code something in one of these tools here so I have all the flexibility that I need, but it's also very simple when n8n does the trick, and most of the time it does, like for all these tools that I have here. It certainly does the trick for me, so that is everything for creating the tools. Now we can go quickly to defining our extremely UI for the front end and interacting with our large language model, and then we'll test it out. So now we get to create the setup to interact with our large language model and set up our streamlet UI so that we can interact with our agent in the browser. So just like with the other tool utility python script, I'm going to start here by importing all the python packages that I need. I'm also importing all of the tools from that other script. And so let me go back over there quick because there's one thing that I forgot to add in, and that is this final mapping here where we take the name of each of our tool functions and we map that to

the actual instance of that function in the script. And so, that way, I take this here, I import it in my main script, and I now have each of these functions imported. And so, what we're going to do is actually take each of these doc strings that we have that help the LLM understand how and when to use each tool. And that's going to be put into the prompt, and that's under the hood using Lane chains. That's how the LLM knows when and how to call these tools to interact with our n8n workflows. We're also going to then load our environment variables just like before, this time just defining the environment variable for the model that we want to use. Can use anthropic or OpenAI models for this setup. Just make sure that you have the right OpenAI or anthropic API key set depending on the model that you are using. With that, we're going to then define our system message here, which is basically just some extra context at the start of the conversation to fine-tune.

how the LLM responds, and so there's just a little couple little examples I have here of ways that I'm being very specific with it so that I get the kind of responses that I want. Telling it things like how to format links for Google Docs B Bas on a document ID. So just a little example there. Then we can get into our functions for actually interacting with the large language model and binding the tools in them. So the first Little Golden Nugget that I have here. I don't really want to get into this in great detail, but I set this up. This helper function right here makes it possible to use anthropic and open AI models even though they both have slightly different formats for how they produce a response when you invoke the model. And so this just kind of handles the difference here and puts it into one single format that works with the rest of the script. So again, I'm not going to dive into that, but this will make it possible for you to use both, which is very, very convenient. And then with that

we can actually get into our function for prompting AI. So, we're going to set up our chatbot here. So, it's going to be a chat OpenAI instance if the model is a GPT model, otherwise chat Anthropic. And then we get all of our tools from that available tool mapping that we have defined right here. And then going back to the script, I find the tools in. So, this is a LangChain function that makes it so simple. This would be a lot of lines of code if it wasn't for LangChain, but it makes it so easy to bind all of our tools in. And then we can invoke our chatbot now with these tools, and we're actually streaming the output. So, I have a little bit of code here to go through all the chunks as it is producing the stream in the typewriter format. And I am gathering that all together and also yielding these chunks as a generator. And so, this is a slightly more advanced Python topic, and I don't want to get into this in a lot of great

detail, but I really wanted to implement this because then that way the AI is going to be typing out its response over time, which looks really, really neat. And so I'm using generators here, yielding these chunks as they are produced from the stream. So again, a little bit more advanced, but it looks really, really cool. And so then what we're going to do after we finish getting the response when it's fully streamed, we're going to check if we have any tool calls. And if we do have any tool calls, then I'm going to add this message into the conversation history so the AI knows later on that it chose to make a tool call here. And then I'm going to loop through every tool call that we want to make because the AI might want to make more than one. And then we will get the name of the tool, get its arguments as well, and then invoke that tool. And we just have a couple of debug print statements here that I'll show in the demo. And then the result of invoking this tool, we're going

to add as a tool message to the conversation because that way AI has context around what actually happened when it decided to invoke this n8n workflow. So, was the message sent successfully in Slack? What was the summary of the Slack conversation? All those different outputs are put in this tool message here so that it can reason about the output. And then what we're going to do is recursively call Prompt AI again to get a response from the LLM now that it has made the tool call. So, it might choose to make another tool call or maybe now it's going to actually produce the final response for the user. Whatever it might be, we have to do that again. And then we're just yielding the chunks from this response resp. So, that is everything for interacting with our LLM. It is really nice and easy. And I even made it more complicated than I had to just to get the streaming in there because I just think it's so cool. But yeah, Lang chain just makes it so fast to make AI agents. And then for our main

function here. I'm just going to add a streamlet title, set our initial messages to a single system message like I defined above, and then every time the streamlet UI refreshes, I want to redisplay everything in the conversation in the UI. And then I'll also define a chat input here where whatever the user types in is going to go into this prompt variable that I'll add to the user interface and also the internal state for the messages. And then I'll prompt the AI, get the stream, and stream that out to the streamlet UI. And then once the stream is complete, add that to the internal message state as well. And that is everything for our UI. And so now we are totally complete. We've got this agent fully set up, and we can go ahead and test it out. To run this AI agent with streamlet, all I have to do is go into the directory that has those pip on scripts I was working on, and then enter the command streamlit run n8n Lang chain agent. That's going to instantly spin up

a new streamlet instance in my browser and take me to it right away. We can see boom, there we go, we got our conversation with just a system message in it right now. And so now I'm going to really quickly show you how we can use all these tools together to do something kind of neat. It's not going to be like insanely powerful, but it's going to show you very clearly how neat this setup is and how easy it is to work with Lang chain, Python, and n8n. And so what I'm going to do here is ask it to summarize the conversation in Slack. And again, the channel's hardcoded, so it knows what channel to do right away. It's going to call that n8n workflow and get that summary, have it return back, and then here we go, boom, that's super nice and easy. Now I can even go to the terminal here and show my debug messages where it decided to invoke this tool, and this is the response that it got back from the n8n workflow call. And so we have a good

summary here and I'm going to actually say, uh, do some research for me on the pros and cons of each. So, I'm going to have it do a little bit of work for me. Maybe you could even have, like, some sort of web search tool that would do some of this and then spit back a response. But in this case, I just wanted to use this internal knowledge to give me some pros and cons of each. So, it's helping me make a decision for my AI startup tech stack. So, I'll say, Great, thanks. Now create a Google doc with your findings. And so, now it's going to go and actually make a Google doc with everything it just spit out to me. And so, we're going to give it a little bit of time. This is going to be a bit of a longer tool call, so I'll pause and come back when this is complete. Okay, I paused for like 5 seconds and then it was done, so super, super quick. But here we go, it's created a Google doc, and it's even linked it for

me, which is super, super nice. Or I can go in my meeting notes folder here that I referenced earlier, scroll down to the bottom, and here we go, text stack research. It picked the title completely on its own, and going into it, we've got all the marked down. That's why it looks kind of silly 'cause it's markdown, all the markdown for the research that it did for me. This is beautiful. And so at this point, we have summarized the Slack conversation and created a Google doc. And so now the last thing we want to do is send a message in Slack. And so I'll say, Fantastic, send this link over to Slack, letting them know that you have done research to solve all their problems. Let's go. So it's going to call that last n and workflow, the last one we have to use, and boom, we sent the message in Slack. And I actually got the notification just now, um, and you can see that I got a new message. So clicking on that, there we go. I've done some research on the Tex stack options. Here's a link.

to the doc with all the research. This is so, so easy. So theoretically, I didn't actually have to touch Slack or Google Drive at all to do any of this. I just wanted to show you that it was all working, but this is just beautiful, and it's using n8n for everything that's actually interacting with these external services. And so, it's just so convenient to set this all up. So there you have it. That is n8n, Python, and Lang chain all combined together to make it very easy to build powerful and controllable AI agents. If you think there is another stack that'd be even better, let me know in the comments. I would love to hear from you other Technologies you'd want me to explore because I'm always open to new ideas for Content. So if you found this valuable and you're going to use this Tech stack to create your own AI agents, I would really appreciate a like and a subscribe. And with that, I will see you in the next video.

Don't Sleep on the ULTIMATE AI Agent Combo (n8n, LangChain, Python)

Scripts