AI Agent

1. Introduction to AI Agents

AI agents are

"entities"

or

"employees"

that can understand instructions and take actions. They are designed to be conversational and perform tasks based on user input.

Key Components of an AI Agent:

• Brain (Large Language Model - LLM): This is the core intelligence of the agent, comparable to models like ChatGPT or Claude 3.5. It processes information and determines responses or actions.

  "the two main components within one are the brain which is basically a large language model like ChatGPT CLA 3.5 something like that"

• Memory: Provides context to the agent by retaining past conversation history. This makes interactions more

  "human-like"

  and ensures future responses and actions are relevant.

  "memory just basically means giving the agent context of what's been going on in a conversation that way it feels more human-like it's more conversational"

  Example: A

  "window buffer memory"

  can be configured to remember a specific number of past messages (e.g., five messages).
• Instructions (System Prompt/Message): Defines the agent's role, behavior, available tools, and how it should take action. This is a static set of rules that guides the agent's overall operation.

  "instructions within an AI agent basically just to fine this is your role this is what you should be doing this is how you act these are the tools you have this is how you take action"

  Distinction: Not to be confused with

  "user messages,"

  which are the dynamic inputs from the user.
• Input: The user's query or message to the agent.

  "the user message is the actual input this is how we're talking to the agent"

• Output: The agent's response or confirmation of an action taken.

  "finally of course it outputs something to us whether that's hey you know we were able to take action for you or whether that's explicitly using a tool like a vector database to pull information back and then returning you that information there's usually some aspect of output"

• Tools: This is where AI agents become powerful. Tools allow the LLM to

  "actually take action."

  An agent can utilize multiple tools to perform diverse functions.

  "when you start to introduce tools this is where the magic really happens because now the large language model has the ability to actually take action"

  The agent uses its

  "brain in combination with the instructions to understand what just came in what was the user message what tool do I need to do because what tool does what function and then how do I actually go out there and take action."

---

2. Building an AI Agent with n8n (No-Code Example)

This demonstrates how to build a simple email agent using n8n, a no-code automation platform.

Step-by-Step Construction:

• Start with the AI Agent Node: In n8n, drag and drop the "AI agent" node. It automatically connects to a "chat message receive" trigger for user input.
• Add a Chat Model (Brain): The agent needs a "brain" to respond. Add a "chat model" subnode (e.g., OpenAI Chat Model).
• API Key Integration: Connect your OpenAI API key as a credential to access their models. Ensure sufficient funds in your OpenAI account to avoid "insufficient funds" errors. Example: Using

  "GPT for mini"

  as the model.
• Add Memory: To give the agent context, add a "memory" subnode.

  "Window buffer memory"

  is recommended for chat-based interactions, as it's easy to set up and references the chat trigger node for session ID and context window length. Demonstration: Without memory, the agent won't remember previous conversational turns (e.g., forgetting the user's name). With memory, it can recall past information.
• Add Tools: Tools enable the agent to perform specific actions.
  • Gmail Tool (Sending Emails):
    • Connect Google credentials.
    • Configure

      "To," "Subject,"

      and

      "Message"

      fields as

      "expressions"

      using the from AI function. This allows the AI to dynamically extract this information from the user's query. Example from AI keys: email recipient, subject, email body.
    • Name the node (e.g.,

      "send email"

      ) for clarity in the system prompt.
    • Optional: Turn off

      "append and attribute"

      to remove n8n branding from emails.
  • Google Sheets Tool (Contact Database):
    • Connect Google credentials.
    • Select the relevant Google Sheet (e.g.,

      "contact database"

      ) and sheet within it.
    • Name the node (e.g.,

      "contact database"

      ) for the agent to reference it.
    • Purpose: Allows the agent to retrieve contact information (like email addresses) from a database based on a person's name, rather than requiring the user to type the email address every time. This can be extended to CRMs, AirTable, or Vector databases.
• Configure System Message (Instructions): This is crucial for guiding the agent's behavior and tool usage.
  • Add a

    "system message"

    option to the AI agent node.
  • Use a custom GPT (or similar tool) to craft a detailed system message that includes:
    • Overview: General role (e.g., "helpful assistant").
    • Context: What the agent does.
    • Instructions: How it should act and respond.
    • Tools: Explicitly define each tool, its name, and its function (e.g.,

      "send email tool to send emails," "contact database tool retrieves contact data such as email addresses"

      ).
    • Examples: Provide example interactions.
    • Standard Operating Procedure (SOP).
    • Final Notes: Any specific directives (e.g.,

      "always sign off the emails from Frank"

      ).
  • Paste the markdown-formatted system message into n8n as an expression.

---

3. Agent Operation and Logs

Workflow: User Input -> AI Agent (Brain + System Message + Memory) -> Tool Action (e.g., Send Email, Lookup Contact) -> Output.

Logs:

n8n provides detailed logs within the AI agent node, showing the steps the agent took:

• User message saved to memory.
• Chat model processes input, references prompt, and identifies necessary tools.
• Tool parameters are created using AI (e.g., email recipient, subject, email body).
• Tool executes (e.g., Gmail sends email).
• Response from tool is received (e.g., email ID from Gmail).
• Chat model crafts response to user based on action.
• Memory is updated.

---

4. Expanding Agent Capabilities

• Dynamic Inputs and Outputs: While demonstrated with n8n's internal chat, agents can be connected to various external platforms:
  • Inputs: Telegram, phone, Slack, etc. (acting as triggers).
  • Outputs: Pushing responses to other services.
• Backend Applications: AI agents can function as complete backend applications.
• Real-world Example: An email agent connected to ElevenLabs for a phone conversation, allowing real-time voice commands to send emails.

  "I actually just made a video very similar to this about a email agent where I connected the input and the output to 11 Labs so that I was having a phone conversation basically with this agent and in real time when I was asking it to send emails it was doing so and we kind of saw it take place and then it would respond to me after the email was sent and say I sent that off for you"

---

5. Conclusion

Building AI agents, even complex ones, can be quick and straightforward, especially with no-code tools like n8n and functions like from AI. Understanding the core components (brain, memory, instructions, tools) is key to designing effective agents capable of taking dynamic actions based on user queries.