These agents are designed to interpret, reason, and plan actions—leveraging Large Language Models (LLMs) while remaining fully integrated into the enterprise-grade governance of the UiPath Orchestrator.

1. What Are Coded Agents?

Coded Agents are software agents written directly in code (e.g., Python or JavaScript) using supported frameworks, integrated into the UiPath automation ecosystem. Unlike low-code agents created via drag-and-drop tools, these agents give developers full control over logic, reasoning, integrations, and behavior — while still benefiting from UiPath’s cloud orchestration, logs, compliance rules, and governance.

In simpler terms, think of coded agents as programmable autonomous workers that:

• Take goals and context as input,
• Reason using AI and external tools,
• Act on behalf of users in complex workflows,
• Integrate deeply with business systems and automation services.

2. Core Architecture and Capabilities

Coded agents bridge the gap between flexible AI frameworks and rigid enterprise requirements. They are packaged as standard .nupkg files and deployed as processes within Orchestrator folders.

• Logic Control: Developers have complete control over state management, complex loops, and custom error handling that might be cumbersome in a visual flow.
• Seamless Integration: Using the UiPath SDK, agents can programmatically interact with:
  • Assets: For secure credential and secret management.
  • Storage Buckets: For handling unstructured data files.
  • Data Service: For structured business data.
  • Orchestrator Jobs: To trigger or monitor other RPA processes.
• Tracing & Observability: Native integration with LangSmith allows for deep inspection of LLM reasoning paths, ensuring transparency in AI decision-making.

Supported Frameworks & SDKs

UiPath provides specialized SDKs to accelerate the development of sophisticated multi-agent systems.

Why Coded Agents Are Important

1. Advanced Customization

With coded agents, developers can embed:

• Complex reasoning,
• Domain-specific logic,
• Custom memory and planning loops,
• Integration with APIs and services beyond UiPath’s built-in activities.

2. Enterprise-Ready Deployment

Once built, coded agents are packaged, published, and deployed through UiPath Orchestrator just like traditional automations — ensuring scalability, security compliance, monitoring, and scheduling.

3. Unified Governance

Businesses get standardized governance, audit trails, human-in-the-loop approvals, and logging — all essential for regulated industries.

How Coded Agents Work

1. Developer Creation

Developers write agent logic in their preferred environment (IDE) using supported frameworks like LangChain, LangGraph, or LlamaIndex. This code defines:

• Perception (input handling),
• Reasoning (AI decision making),
• Action (APIs, workflows, data operations).

2. Integration with UiPath SDK

Using the UiPath SDK, coded agents connect to platform services, such as:

• Orchestrator APIs,
• Context storage (assets, buckets),
• LLM gateways and model endpoints.

3. Packaging and Deployment

A simple CLI command packages the agent for UiPath’s cloud. Once deployed:

• Agents can be scheduled,
• Observed via dashboards,
• Governed and approved within enterprise rules.

Development Lifecycle: From IDE to Orchestrator

The development process for a coded agent mirrors the modern software development lifecycle (SDLC) while retaining the benefits of the UiPath ecosystem.

1. Initialization: Use the CLI command uipath new <agent_name> to generate a project structure. This creates essential files like uipath.json (to expose functions) and requirements.txt.
2. Logic Development: Write your Python logic in an IDE (like VS Code). You can utilize the uipath-python SDK to fetch assets or start other jobs.
3. Authentication: Authenticate your local environment using uipath auth to link your IDE to your UiPath tenant.
4. Packaging: Run uipath pack to compile your code into a .nupkg package.
5. Deployment: Run uipath publish to send the package to the Orchestrator feed.
6. Execution: In Orchestrator, create a process from the package. It can now be triggered by events, APIs, or schedules.

Human-in-the-Loop (HITL)

Coded agents are not purely “black box” autonomous systems. You can programmatically define interrupt points to ensure human oversight:

• Action Center Integration: When an agent reaches a high-risk decision, it can create a task in the UiPath Action Center.
• Execution Pause: The agent process enters a “suspended” state, freeing up robot resources while waiting for human input.
• Resumption: Once the user completes the action (e.g., approving a budget or correcting an extraction), the agent resumes exactly where it left off.

Licensing and Consumption (2026 Model)

Usage is governed by a consumption-based model involving Agent Units or Platform Units.

• LLM Calls: 1 LLM call typically consumes 0.2 Platform/Agent Units.
• Execution Time: Agent runs are measured in 5-minute increments. A run under 5 minutes equals 1 execution unit.
• Trial/Community: Community users often receive a daily allotment (e.g., 250–350 LLM calls) to facilitate development and testing.

Note: Context Grounding queries and specific high-tier LLM models may be charged at different rates. Always refer to the Consumables tab in your Automation Cloud Admin portal for real-time tracking.

Coded Agents vs. Traditional RPA and Low-Code Agents

Typical Use Cases

1. Conversational Bot Controllers

A coded agent interprets natural language and triggers RPA jobs accordingly — e.g., “Start invoice processing bot.”

2. Intelligent Document Retrieval

Agents using LlamaIndex can turn unstructured document collections into intelligent search assistants within workflows.

3. End-to-End Workflow Planners

Agents can orchestrate multi-step processes across systems — from CRM updates and data validation to email responses.

4. AI-Driven Case Management and Ticket Routing

Define custom logic to classify, respond, escalate, or route service tickets based on AI reasoning.

## Troubleshooting and Support

• SDK-Level Issues: Errors regarding the Python library itself (e.g., uipath-python) should be reported via the respective GitHub Repository.
• Platform/Runtime Issues: Issues with Orchestrator deployment, Serverless Robot execution, or licensing should be handled through UiPath Official Support.

Build LangGraph-Powered AI Agents in UiPath

This video provides a deep dive into how developers can use the Python SDK to build and deploy intelligent agents within the UiPath ecosystem.

Picture every retailer trying to connect with every potential sales channel individually—Walmart building custom integrations for Google’s AI, Shopify for Amazon’s Alexa, Target for whatever comes next. This “N x N” integration bottleneck has stifled innovation for years, forcing businesses to choose between supporting new technologies and maintaining existing infrastructure. Today, Google’s Universal Commerce Protocol (UCP) emerges as the solution to this fundamental challenge, providing the missing connective tissue for the next generation of commerce.

Developed collaboratively with industry leaders including Shopify, Etsy, Wayfair, Target, and Walmart, and endorsed by over 20 global partners from Adyen to Zalando, UCP represents a paradigm shift in how commerce systems communicate. It’s not just another API—it’s an open-source standard designed to create a common language for the entire commerce ecosystem as we transition into the agentic era.

What Exactly Is the Universal Commerce Protocol?

At its core, UCP is a functional primitive framework that enables seamless commerce journeys between consumer surfaces (like AI assistants), businesses, and payment providers. Think of it as the “HTML for commerce”—a standardized way for different systems to understand products, inventory, pricing, and transactions without requiring custom integrations for every new platform.

The Protocol’s Revolutionary Architecture

Unlike legacy systems that treat commerce as a series of disconnected transactions, UCP standardizes the entire commerce lifecycle through a single, secure abstraction layer built on three key principles:

1. Unified Integration Framework
Instead of businesses building bespoke connections for every new AI platform or shopping surface, UCP collapses complexity into a single integration point. A retailer integrates once with UCP and automatically becomes discoverable and transactable across all UCP-compatible surfaces—from Google’s AI Mode in Search to future platforms we haven’t even imagined yet.

2. Capability-Based Communication
UCP introduces a sophisticated capabilities model where businesses expose what they can do—not just what they have. These capabilities include:

• Core Building Blocks: Product discovery, checkout, order management
• Extensions: Specialized functionality like discounts, fulfillment options, or loyalty programs
• Dynamic Discovery: Agents can discover available capabilities through standardized JSON manifests

3. Payment-Agnostic Design
UCP’s most innovative feature might be its modular payment handler architecture, which separates payment instruments (what consumers use to pay) from payment handlers (the processors). This enables true payment interoperability while maintaining cryptographic proof of user consent for every transaction—a security-first approach that builds trust into the protocol’s DNA.

Why the Ecosystem Is Rallying Around UCP

The protocol represents a rare win-win-win scenario across the commerce landscape:

For Businesses: Control Meets Accessibility

• Merchant of Record Retention: You maintain full control over your business logic and remain the merchant of record
• Flexible Integration Options: Choose between APIs, Agent2Agent (A2A) communication, or the Model Context Protocol (MCP) based on your technical stack
• Embedded Checkout: Maintain fully customized checkout experiences from day one while participating in the broader ecosystem
• Future-Proofing: The extensible architecture scales as new agentic experiences emerge

For AI Platforms & Developers: Simplicity at Scale

• Standardized Onboarding: Simplify business integration using consistent APIs while allowing flexibility in implementation
• Open-Source Foundation: Built to be community-driven with transparent evolution
• Reduced Development Burden: Focus on creating innovative experiences rather than building endless custom integrations

For Payment Providers: Interoperability Without Compromise

• Open, Modular Design: Enables choice of payment methods while maintaining security
• Provable Transactions: Every authorization includes cryptographic proof of user consent
• Universal Compatibility: Works alongside existing systems like the Agent Payments Protocol (AP2)

For Consumers: Frictionless Discovery to Decision

• Seamless Experiences: Move from brainstorming to purchase without changing contexts
• Peace of Mind: Cryptographic security and clear consent mechanisms
• Best Value Recognition: Member benefits and loyalty programs travel with you across surfaces

How UCP Works in Practice: A Technical Walkthrough

Let’s trace a practical implementation using the example of a flower shop integrating with UCP:

Step 1: Business Server Setup
The retailer sets up a UCP-compatible server that exposes their products and capabilities. Using the open-source UCP SDK, they can quickly stand up a server that understands the protocol’s language for product data, inventory, and transactions.

Step 2: Capability Exposure
The business publishes a standardized manifest at /.well-known/ucp that declares:

• Available services (like shopping or food delivery)
• Supported capabilities (checkout, discount application, fulfillment options)
• Payment handler configurations
• Communication endpoints

Step 3: Agent Discovery
When an AI agent (like one in Google’s Gemini) wants to help a user buy flowers, it queries the business’s UCP endpoint. The response might look like:

{
  "ucp": {
    "version": "2026-01-11",
    "services": { 
      "dev.ucp.shopping": {
        "version": "2026-01-11",
        "endpoint": "https://flowershop.example/ucp/"
      }
    },
    "capabilities": [
      { "name": "dev.ucp.shopping.checkout" },
      { "name": "dev.ucp.shopping.discount" },
      { "name": "dev.ucp.shopping.fulfillment" }
    ]
  }
}

Step 4: Transaction Execution
The agent can then invoke capabilities—creating a checkout session, applying discounts, or selecting fulfillment options—all through standardized UCP calls. The entire process maintains security through request signatures and idempotency keys while giving the business full control over pricing, inventory, and fulfillment logic.

Google’s Reference Implementation: Bringing UCP to Life

While UCP is designed as a vendor-agnostic standard, Google has built the first reference implementation to demonstrate its potential. This implementation powers new buying experiences in AI Mode in Search and the Gemini app, allowing consumers to move seamlessly from discovery to purchase.

The Google Integration Path:

1. Merchant Center Foundation: Businesses need an active Google Merchant Center account with eligible products
2. UCP Compliance: Implement the UCP specification for product discovery and checkout capabilities
3. Checkout Experience: Enable consumers to purchase using saved payment and shipping information from Google Wallet

Example Query Flow:
When a user asks Gemini, “Find a lightweight suitcase for my trip to Japan,” the AI can:

• Discover products from UCP-enabled retailers
• Check real-time inventory and pricing
• Initiate checkout through the user’s preferred payment method
• Complete the purchase without leaving the conversational context

The Collaborative Future of Commerce

What makes UCP truly revolutionary isn’t just its technical design but its open-source, collaborative development model. By inviting the entire ecosystem—from global retailers to independent developers—to contribute to the specification, Google is fostering a community-driven approach to solving commerce’s most persistent challenges.

Getting Involved:

• Explore the Specification: Available on GitHub with complete documentation
• Participate in Discussions: Shape the protocol’s evolution through GitHub Discussions
• Contribute Code: Submit pull requests and help build the next generation of commerce infrastructure
• Integrate and Experiment: Use the provided SDKs and samples to prototype UCP-enabled experiences

The Big Picture: Why This Matters Now

As consumers increasingly embrace conversational interfaces and AI assistants, they expect commerce to work like natural conversation—fluid, contextual, and complete. UCP provides the technical foundation to make this possible at scale, transforming how businesses connect with customers in the agentic era.

The protocol represents more than just a technical standard; it’s a philosophical shift toward interoperability, user control, and ecosystem collaboration. By solving the N x N integration problem, UCP frees businesses to focus on what they do best—creating great products and experiences—while giving AI platforms the tools to deliver truly helpful commerce assistance.

As the first wave of implementations rolls out from Google and its partners, we’re witnessing the early stages of a commerce revolution that promises to make shopping more intuitive, accessible, and human-centered than ever before. The universal language of commerce has arrived, and it’s open for everyone to speak.

References

Under the Hood: Universal Commerce Protocol (UCP) – Google Developers Blog

UiPath’s Agentic Automation platform provides powerful tools to systematically measure and improve your agent’s performance. The key to leveraging these tools effectively is organization. In this blog post, we’ll break down the best practices for structuring your evaluations, from grouping them into logical sets to choosing the right scoring engines, or “evaluators.”

The Core Philosophy of AI Agent Evaluation

At its heart, evaluating an AI agent is no different from quality assurance in software development or performance review for an employee. The goal is to systematically answer one critical question: “Is this agent reliably performing its intended task to the required standard?”

This moves you from anecdotal testing (“Let me try a few queries”) to empirical, measurable validation (“Based on 200 test cases, the agent achieves 95% accuracy on core tasks”).

The Universal “Why”: Why Evaluate AI Agents?

Think of an AI Agent as a new employee. You wouldn’t deploy them to handle critical business tasks without training and checking their work. Evaluation is that continuous training and quality check process.

• Reliability: Ensures the agent performs consistently, not just correctly on one lucky try.
• Accuracy: Measures if the agent’s outputs are factually correct and meet the task requirements.
• Robustness: Tests how the agent handles edge cases, errors, and unexpected inputs without breaking.
• Improvement: Provides a feedback loop to iteratively improve the agent’s prompts, tools, and reasoning (e.g., using RAG).
• Trust: Builds confidence to deploy the agent into production processes.

What are Evaluators?

Evaluators are the measurement mechanisms used to check if an agent is doing its job well. They can be:

• Rule-based evaluators → Compare agent output against expected results (ground truth).
• Metric-based evaluators → Use quantitative scores (e.g., accuracy, precision, latency).
• Human evaluators → End-users or SMEs rate usefulness, correctness, clarity.
• LLM-as-a-judge evaluators → Another AI model scores the agent’s output quality (used in LLM/agent frameworks like LangChain, LlamaIndex, DSPy).

What is Evaluation?

Evaluation is the systematic process of testing agent behavior across dimensions like correctness, robustness, usability, and business value.

It helps answer questions like:

• Does the agent solve the intended problem?
• Is it reliable under different conditions?
• Does it align with business and compliance needs?

Techniques for Evaluation (Across Frameworks)

Why Group Evaluations into Sets?

Trying to test every possible scenario in one disorganized list is inefficient and unclear. Grouping your evaluations into purposeful sets allows you to:

• Focus your testing on specific areas of your agent’s behavior.
• Interpret results more easily by understanding the context of any failures.
• Manage your test suites efficiently as your agents evolve.

UiPath recommend creating Below primary types of evaluation sets to cover all bases:

1. The Full Output Evaluation Set
This is your foundation—the suite of tests that validate normal, expected behavior under typical conditions.

• Purpose: To verify core functionality and logic.
• What it covers:
  • Basic Functionality: Does the agent produce the correct output for valid inputs?
  • Core Logic: Are calculations, data comparisons, and field validations working correctly?
• Example Tests:
  • Does the total on an extracted invoice match the sum of its line items?
  • Is the format of dates, currencies, and numbers correctly validated?
• Benefit: This set gives you confidence that the primary functions of your agent are working as expected. It’s your essential first pass.

2. The Edge Case Evaluation Set
This set is designed to probe the boundaries and robustness of your agent, testing how it handles rare, unexpected, or extreme conditions.

• Purpose: To uncover hidden bugs that don’t appear in normal operation.
• What it covers:
  • Input Boundaries: Testing with maximum/minimum values (e.g., extremely high quantities or totals).
  • Abnormal Inputs: How does it handle empty fields, extremely long text, or unusual data formats?
  • Unusual Conditions: Testing with missing or incomplete data.
• Example Tests:
  • What happens if an invoice total exceeds the system’s maximum allowed value?
  • How does the agent react if a required field like VendorName is missing?
• Benefit: This set is crucial for ensuring stability and preventing crashes or errors in non-ideal, real-world scenarios.

3. The Misspelling and Typographical Error Set
Users and upstream systems make mistakes. This set tests your agent’s ability to handle imperfect input gracefully.

• Purpose: To ensure the agent is user-friendly and robust enough to handle common input errors.
• What it covers:
  • Misspelled Fields (e.g., “VenderName” instead of “VendorName”).
  • Partial Matches & Case Sensitivity (e.g., “ABC Corp.” vs. “ABC Corporation”).
  • Unexpected Characters like leading/trailing spaces or special symbols.
• Example Tests:
  • If a user enters “Acme Co.” but the system expects “Acme Company,” does it flag an error or use fuzzy matching to understand?
  • How does it handle accidental spaces in a PONumber field?
• Benefit: This testing ensures your automation is resilient and can process data successfully even when input isn’t perfect, which is vital for real-world deployment.

Mastering UiPath Agent Evaluations

The Engine of Evaluation: Understanding Evaluators

Evaluation sets define what to test, but Evaluators define how to score the results. They are the scoring engines that determine whether an agent’s output meets your quality bar. Without them, evaluations are just snapshots of expected output.

UiPath provides several types of evaluators to match your needs:

The Lifecycle of an Evaluator

1. Create: Build your evaluator in the Evaluators panel. Choose its type and give it a clear, semantic name (e.g., “US-Invoice-Totals-Range”).
2. Attach: Assign one or more evaluators to an evaluation set. You can mix and match types (e.g., use an Exact Match for a status code and an LLM-as-a-Judge for a summary field).
3. Version: Any change to an evaluator creates a new version. This maintains historical audit trails. For CI/CD pipelines, pin evaluator versions just like you would package dependencies.
4. Retire: If business rules change, clone an evaluator and edit the clone. Never edit an existing evaluator in-place if you need to maintain auditability for past runs.

When to Create Your Evaluations

The best time to build your evaluation sets is once your agent’s arguments are stable and complete—meaning your use case, prompts, tools, and Context Grounding indexes are finalized. This minimizes rework. If you modify your agent’s design later, you will need to adjust your evaluations accordingly.

A major advantage of this system is reusability. You can easily export and import evaluation sets between agents in the same organization or even across different organizations, saving you from rebuilding them from scratch.

Example of Creating Evaluation

Agent : Internal IT Support Triage and Resolution Agent

This AI agent is designed to automate and enhance the Level 1 IT support function within an organization. Its core use case is to instantly handle incoming employee queries via a chat interface (e.g., Microsoft Teams, a web portal, or service desk email), reducing resolution time and freeing human agents for more complex tasks. The agent intelligently parses the user’s request, cross-references it against a curated internal knowledge base of IT guides and FAQs, and determines the optimal response path.

For common, resolvable issues—such as configuring Outlook settings, troubleshooting Excel errors, or guiding users through SharePoint sharing permissions—the agent provides immediate, clear, and structured step-by-step instructions directly within the chat. For issues that require administrative access, specialized skills, or physical intervention—such as creating new Teams channels, restoring mailbox access, or handling software crashes—the agent automatically generates a pre-formatted support ticket, accurately categorizes it, and assigns it to the correct resolver group (e.g., O365_Teams_ChannelCreation, O365_SharedMailbox_Access). This ensures seamless escalation, provides users with clear expectations, and integrates directly with the company’s existing IT Service Management (ITSM) workflow.

1. The Full Output Evaluation Set

This set is designed to test the agent’s ability to provide complete, accurate, and helpful step-by-step solutions for common but non-trivial technical issues.

Purpose: To evaluate the agent’s core knowledge, clarity of instruction, and ability to structure a helpful response.

Examples:

Name: Laura
Message: I accidentally deleted an important email in Outlook. Is there a way to recover it?
Expected Output:
Hello Laura, thank you for reaching out. Yes, deleted emails in Outlook are often recoverable. Here’s how you can try to get it back:

1. Check the “Deleted Items” Folder: First, look in your Deleted Items folder. If it’s there, you can simply right-click the email and select “Move” > “Inbox” or another folder.
2. Recover from “Recoverable Items”: If you’ve emptied the Deleted Items folder, the email may still be in a hidden folder for a limited time.
   • In your Outlook folder pane, click on the “Deleted Items” folder.
   • On the “Home” tab, click “Recover deleted items” (or in Outlook on the web, click “Recover items deleted from this folder”).
   • A dialog box will open. Select the email(s) you want to recover and click “Restore Selected Items”. The emails will be moved back to your Deleted Items folder.

If these steps don’t work, and the email was critically important, you may need to contact your IT admin, as they might be able to restore it from a server-level backup. Let me know if you need further assistance!

Name: David
Message: How do I stop Excel from changing my numbers into dates? It’s very frustrating.
Expected Output:
Hi David, that’s a common and understandably frustrating issue. Excel tries to be “helpful” by auto-formatting data. Here are the best ways to prevent this:

1. Pre-format the Cells (Recommended):
   • Select the column or cells where you will enter your numbers.
   • Right-click and choose “Format Cells”.
   • Select “Text” from the Category list and click “OK”. Now, anything you type in these cells will be treated as text and not converted to a date.
2. Use an Apostrophe:
   • Before typing a number that could be misinterpreted (like 1-2), type an apostrophe ('). For example, type '1-2. The apostrophe will not be visible in the cell, but it forces Excel to treat the entry as text.
3. Import Data Using Text Import Wizard:
   • If you’re importing data from a .CSV or text file, use Data > From Text/CSV.
   • In the preview window, select the problematic column and change its data type to “Text” before loading it.

This should give you full control over how your data is displayed. Hope this helps!

Name: Chloe
Message: My OneDrive sync keeps saying “Processing changes” for hours and won’t finish. What can I do?
Expected Output:
Hello Chloe, a stuck OneDrive sync is usually resolved by resetting the client. Don’t worry, this won’t delete your files. Please follow these steps:

1. Close OneDrive Completely: Right-click the OneDrive cloud icon in your taskbar notification area and click “Close OneDrive”.
2. Reset OneDrive: Press Win + R, type the following command, and press Enter:
   %localappdata%\Microsoft\OneDrive\onedrive.exe /reset
   (Note: A command window may flash briefly; this is normal).
3. Restart OneDrive: Press Win + R again, type this command, and press Enter:
   %localappdata%\Microsoft\OneDrive\onedrive.exe
4. Wait for Sync to Restart: It may take a few minutes for the icon to reappear and for syncing to begin again. This process clears the local sync cache and often resolves persistent “Processing changes” issues.

If the problem continues, there might be a problem with a specific file. Let me know, and we can try more advanced troubleshooting like pausing sync and syncing folders one-by-one.

2. The Edge Case Evaluation Set

This set tests the agent’s ability to handle ambiguity, lack of information, complex multi-part requests, and scenarios where a direct solution isn’t possible, requiring escalation or clarifying questions.

Purpose: To evaluate the agent’s logical reasoning, communication skills, and understanding of its own limitations.

Examples:

Name: Mark
Message: It doesn’t work.
Expected Output:
Hi Mark, I’m sorry to hear you’re having trouble. To help you effectively, I’ll need a bit more information.
Could you please describe:

• What application or service “doesn’t work” (e.g., Outlook, Teams, Excel)?
• What were you trying to do when you encountered the issue?
• Are you seeing a specific error message? If so, what does it say?

The more details you can provide, the better I can assist you.

Name: Sophia
Message: I need full access to the Finance SharePoint site, the ability to edit the budget Excel file that’s there, and also my printer isn’t working.
Expected Output:
Hello Sophia, thank you for your message. I understand you have three separate requests:

1. Access to Finance SharePoint Site: Access permissions for SharePoint sites are managed by the site owners or your IT administration team. I will create a support ticket for the SharePoint_Access team to process your access request.
2. Edit Permissions for Budget File: Editing permissions for a specific file are also managed by the file owner or site admin. I have added this detail to the ticket.
3. Printer Issue: Printer troubleshooting is handled by a different specialist team. I will create a second, separate ticket for the Hardware_Printing team to assist you with that.

You will be contacted shortly by both teams. Thank you for your patience.

Name: Ben
Message: My boss needs a report of all emails sent from our department last quarter for an audit. How do I get that?
Expected Output:
Hello Ben, that sounds like an important request for compliance. Generating that type of comprehensive email audit report typically requires administrative privileges and access to the Microsoft Purview compliance portal or Exchange Admin Center, which is not available to standard users.

This request will need to be handled by your organization’s Compliance or IT Administration team. I have created a high-priority support ticket and assigned it to the Compliance_Audit_Reporting team. They have the tools and permissions necessary to generate and provide that report for you. They will contact you shortly to confirm the exact details of the audit requirements.

3. The Misspelling and Typographical Error Set

This set tests the agent’s robustness and ability to use intent recognition to understand user queries despite spelling mistakes, grammatical errors, and auto-correct artifacts.

Purpose: To evaluate the agent’s Natural Language Processing (NLP) capabilities and fault tolerance.

Examples:

Name: Rachel
Message: How can I sheare a foleder in Teams? I need to colaborate on documments.
Expected Output:
Hello Rachel, absolutely! To share a folder in Microsoft Teams for collaboration, the best way is to add the folder to a Teams channel. Here’s how:

1. Go to the specific channel within your team.
2. Click on the “Files” tab at the top.
3. Click “Upload” and select the folder from your computer. This will upload the entire folder and its contents to the channel’s associated SharePoint site.
4. Once uploaded, everyone in the team will have access to the folder and can collaborate on the documents inside it in real-time.

This is much more effective than sharing separately via email. Let me know if you need help with the specific steps!

Name: Thomas
Message: outlook keeps askng for my pasword every 5 minits its so anoying
Expected Output:
Hi Thomas, I understand that’s very annoying. The constant password prompts are usually caused by a corrupted Outlook profile or incorrect credential storage. Here are the most effective solutions:

1. Check Credential Manager:
   • Press Win + R, type control.exe /name Microsoft.CredentialManager, and press Enter.
   • Go to “Windows Credentials”.
   • Look for any Outlook-related credentials (e.g., MicrosoftOffice[email]) and remove them. Restart Outlook and it will prompt you to enter your password fresh, which often fixes the loop.
2. Create a New Outlook Profile (If above fails):
   • Go to Control Panel > Mail (Microsoft Outlook) > Show Profiles.
   • Click “Add…” to create a new profile, set it up with your email account, and set it as the default.
   • You can then remove the old profile.

Try the first step first—it resolves the issue most of the time. If it doesn’t work, let me know and we can escalate to the O365_Outlook_Config team.

Name: Jessica
Message: can u help me instal power bi desktop i cant find the downlod
Expected Output:
Hello Jessica, I can certainly help with that! Here is the direct link to download Power BI Desktop from the official Microsoft website:

Download Power BI Desktop: https://aka.ms/pbidesktopstore

(You can simply click that link or copy and paste it into your browser).

Once the download is complete, run the installer and follow the on-screen instructions. It’s a straightforward process. After installation, you can sign in with your work account to get started. Let me know if you encounter any issues during the installation!

Key Coverage Principles to Follow

• Logical Coverage Over Quantity: Don’t just add more of the same test. Map out all possible input combinations, decision branches, and boundary conditions. Ensure each unique path is tested.
• Manage Redundancy: For each unique logical case (e.g., “password reset”), 3-5 evaluations with slightly different phrasings are sufficient to ensure consistency without cluttering the dataset.
• Quality is Paramount: A well-designed set of 50 evaluations that tests all critical paths is far more valuable than 200 repetitive or low-quality tests. Focus on meaningful scenarios that reflect real-world use and potential failures.
• Iterate: Evaluations are not a one-time task. As you add new features or intents to your agent, you must expand your evaluation sets to cover them.

Start Building with Confidence

A structured approach to evaluation is not just a best practice—it’s a necessity for deploying trustworthy and robust AI agents. By grouping your tests into logical sets and leveraging the power of different evaluators, you can gain deep, actionable insights into your agent’s performance, ensuring it delivers value reliably.

Ready to put these practices into action?
Dive deeper and start building your evaluation sets today by visiting the official UiPath Agent Evaluations documentation.

UiPath supports four distinct types of MCP Servers, each designed for specific integration scenarios and use cases. Understanding these types is crucial for selecting the right approach for your automation needs :

• UiPath Type: Exposes UiPath artifacts as tools via MCP, including RPA workflows, agents, API workflows, and agentic processes
• Coded Type: Hosts custom-coded MCP Servers developed using languages like Python
• Command Type: Integrates external MCP Servers from package feeds via command-line interfaces
• Remote Type: Connects to remotely deployed MCP Servers through secure tunneling

This comprehensive guide will walk you through the entire process of building, deploying, and managing MCP Servers within the UiPath platform, leveraging official documentation and resources to ensure best practices and optimal implementation.

Prerequisites and Environment Setup

System Requirements and Software Installation

Before developing MCP Servers, ensure your environment meets these prerequisites:

• Python 3.11 or higher: Required for coded MCP Server development 
• Package manager: pip or uv for dependency management 
• UiPath Automation Cloud account: With appropriate permissions for MCP Server management 
• UiPath Personal Access Token (PAT): With Orchestrator API Access scopes 
• UiPath Python SDK: Install using pip install uipath-mcp or uv add uipath-mcp

Authentication Configuration

Proper authentication is essential for MCP Server operations. Configure your Personal Access Token with the necessary scopes:

1. Navigate to UiPath Orchestrator → User → Preferences → Personal Access Token 
2. Generate a new token with Orchestrator API Access (All) scopes 
3. Store the token securely as it will be required for both development and client connections

Project Initialization

Set up your development environment using the following commands:

# Create project directory
mkdir example-mcp-server
cd example-mcp-server

# Initialize UV project (alternative to pip)
uv init . --python 3.11

# Create and activate virtual environment
uv venv
source .venv/bin/activate  # Linux/Mac
# or .venv\Scripts\activate  # Windows

# Install UiPath MCP package
uv add uipath-mcp
# or using pip
pip install uipath-mcp

Or Alternatively you can use the pip based on your preference !

Initialize your UiPath project with the necessary configuration files:

# Initialize UiPath project
uipath init

This command creates essential configuration files including:

• .env: Environment variables and secrets (excluded from publishing)
• uipath.json: Input/output JSON schemas and bindings

All Set !

Building MCP Servers: Development Process

Creating Your First MCP Server

UiPath provides a streamlined process for generating MCP Server templates. Create a new server using the following command:

# Create new MCP server
uipath new math-server

This command generates the necessary files for your MCP Server:

• server.py: Sample MCP server implementation using FastMCP
• mcp.json: Configuration file for coded UiPath MCP Servers
• pyproject.toml: Project metadata and dependencies following PEP 518 

Important Note: The uipath new command removes all existing .py files in the current directory, so ensure you work in a dedicated project folder 

All good here – You should be able to see generated server.py file contains a template for your MCP Server implementation. Below is an example of a math server with basic arithmetic operations:

Alright – All required files and setup is done- next lets build our own custom code for our Logic.

Implementing Server Logic

# Banking Tools MCP Server

A Model Context Protocol (MCP) server implementation that provides banking-related tools and utilities for UiPath automation workflows. This server offers tools for customer data retrieval, fund holdings analysis, credit worthiness assessment, and comprehensive customer risk evaluation.

## Features

- 🏦 **Customer Information Retrieval**
  - Async PostgreSQL database integration
  - Efficient connection pooling
  - Comprehensive error handling

- 📊 **Fund Holdings Analysis**
  - Excel file processing with pandas
  - Asset allocation calculations
  - Historical holdings tracking

- 🔍 **Credit Assessment**
  - Sanctions list checking
  - News sentiment analysis
  - Risk score calculation

- 🏥 **Health Monitoring**
  - Database connectivity checks
  - Service status monitoring
  - Dependency health tracking

@mcp.tool()
async def get_fund_holdings(customer_id: str, month: str) -> Dict[str, Any]:
    """Read customer's fund holdings from Excel file for a specific month.

    Args:
        customer_id: Unique identifier for the customer
        month: Month for which to retrieve holdings (format: YYYY-MM)

    Returns:
        Dictionary containing:
        - Total holdings value
        - List of fund positions
        - Performance metrics

    Raises:
        HTTPException: If file not found or invalid data
    """
    try:
        # Use configured data directory
        file_path = os.path.join(DATA_DIR, month, f"customer_{customer_id}.xlsx")
        
        # Read Excel file using pandas
        df = pd.read_excel(file_path)
        
        # Calculate holdings summary
        holdings_summary = {
            "total_value": float(df["value"].sum()),
            "positions": df.to_dict(orient="records"),
            "asset_allocation": df.groupby("asset_class")["value"].sum().to_dict()
        }
        
        return holdings_summary
    except FileNotFoundError:
        raise HTTPException(status_code=404, detail="Holdings data not found")
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Error processing holdings: {str(e)}")

Configuration Files

Proper configuration is essential for MCP Server functionality. The mcp.json file defines server properties:

{
    "name": "math-server",
    "version": "0.1.0",
    "description": "A sample MCP server for mathematical operations",
    "keywords": ["math", "arithmetic", "calculations"],
    "contacts": [
        {
            "name": "Your Name",
            "email": "your.email@example.com"
        }
    ],
    "capabilities": {
        "resources": true,
        "tools": true
    }
}

The pyproject.toml file contains project metadata and dependencies:

[project]
name = "banking-tools-mcp"
version = "1.0.0"
description = "Basic Banking Tools MCP Server"
requires-python = ">=3.8"
dependencies = [
    "uipath-mcp>=0.0.101",
    "fastapi",
    "sqlalchemy[asyncpg]",
    "pandas",
    "python-dotenv",
    "aiohttp",
    "uvicorn"
]

[build-system]
requires = ["hatchling"]
build-backend = "hatchling.build"

[tool.hatch.build]
include = [
    "*.py",
    "*.json",
    "*.md",
    "requirements.txt"
]

[tool.hatch.metadata]
allow-direct-references = true

[tool.ruff]
line-length = 100
target-version = "py38"
select = ["E", "F", "I"]
ignore = ["E501"]

[tool.ruff.isort]
known-first-party = ["banking_tools"]
known-third-party = ["fastapi", "sqlalchemy", "pandas", "aiohttp"]

Testing and Deployment

Test your MCP Server locally before deployment:

• Set folder path environment variable:

The common issue you might face here is your environment variable is not set.

uipath run banking-server

Once started successfully, your MCP server will appear in Orchestrator’s MCP Servers tab

Test with MCP clients: Use tools like Claude Desktop or MCP Inspector to validate functionality

Packaging and Publication

Prepare your MCP Server for deployment to UiPath Automation Cloud:

Update package metadata in pyproject.toml:

authors = [{ name = "Your Name", email = "your.name@example.com" }]

Package your project:

uipath pack

Publish to Automation Cloud:

The --my-workspace flag simplifies deployment by automatically handling serverless machine allocation and permissions .

uipath publish --my-workspace

Orchestrator Configuration

After publishing, configure your MCP Server in UiPath Orchestrator:

1. Navigate to the MCP Servers tab in your target folder
2. Select Add MCP Server
3. Choose the appropriate server type (Coded for custom servers)
4. Select your published process (e.g., banking-server)
5. Click Add to deploy the server 

Once deployed, the server automatically starts and registers its available tools. You can monitor the job status in the MCP Server side panel 

MCP Server Management and Best Practices

Orchestrator Management

UiPath Orchestrator provides comprehensive management capabilities for MCP Servers:

• Server Creation: Add new MCP Servers through the Orchestrator interface, selecting from four types (UiPath, Coded, Command, or Remote) 
• Tool Management: For UiPath-type servers, add tools that include UiPath artifacts such as RPA workflows, agents, API workflows, and agentic processes 
• Editing and Updates: Modify server configurations through the Edit option (note: server type cannot be changed after creation) 
• Deletion: Remove unnecessary servers through the Remove option 

Security Best Practices

Implement robust security measures for your MCP Servers:

• Use trusted providers for external, coded, or remote servers 
• Implement OAuth 2.1 compliance for HTTP-based transports 
• Apply principle of least privilege for token scopes (Executions scope for listing tools, Jobs scope for starting jobs) 
• Never use session IDs for authentication; generate non-predictable session identifiers 
• Minimize data exposure in responses and implement proper error handling

Troubleshooting and Common Issues

Even with proper implementation, you may encounter challenges when working with MCP Servers. Here are common issues and their solutions:

Authentication Problems

Issue: “401 Unauthorized” or “403 Forbidden” errors when connecting to MCP Servers 
Solution:

• Verify your PAT has the correct scopes (Orchestrator API Access)
• Ensure the token is properly formatted in authorization headers: Authorization: Bearer <your_token>
• Check token expiration and generate a new one if needed

Connection Issues

Issue: MCP Server not appearing in Orchestrator after deployment 
Solution:

• Verify the UIPATH_FOLDER_PATH environment variable is correctly set
• Check that the server is properly registered with UiPath during startup
• Validate network connectivity and firewall settings

Tool Visibility Problems

Issue: Tools not visible or accessible in MCP clients 
Solution:

• Ensure tools are properly decorated with @mcp.tool() decorator
• Verify the MCP Server has the necessary capabilities declared in mcp.json
• Check that the server is running and accessible

Documentation Gaps

Issue: Limited documentation for specific scenarios 
Solution:

• Refer to the UiPath Community Forum for shared experiences
• Check GitHub repositories for examples and sample implementations
• Utilize the official UiPath documentation as the primary source 

Conclusion and Next Steps

Building MCP Servers in UiPath represents a powerful approach to integrating AI capabilities with robotic process automation. By following this step-by-step guide, you can create, deploy, and manage MCP Servers that enhance your automation workflows with intelligent context awareness and decision-making capabilities.

Continued Learning

To further develop your MCP Server expertise:

• Explore the UiPath Python SDK documentation for advanced features and capabilities
• Experiment with different MCP Server types to understand their respective strengths
• Join the UiPath Community Forum to learn from others’ experiences and share your insights 
• Review additional sample implementations on GitHub for practical inspiration

Strategic Implementation

As you advance in your MCP Server development:

• Start with contained use cases before expanding to mission-critical processes
• Prioritize security and governance from the beginning of your implementation
• Design for scalability considering future growth and additional integrations
• Establish monitoring practices to ensure reliability and performance

MCP Servers continue to evolve within the UiPath platform, offering increasingly sophisticated capabilities for intelligent automation. By mastering MCP Server development now, you position yourself and your organization to leverage the full potential of AI-enhanced automation as the technology continues to advance.

The Model Context Protocol (MCP) has emerged as a transformative standard in the realm of Robotic Process Automation (RPA), enabling seamless integration between AI capabilities and enterprise automation systems. This comprehensive article explores how MCP serves as a universal connector between RPA platforms like UiPath and Automation Anywhere and external data sources, applications, and AI services.

We examine the substantial value proposition of MCP implementation, including enhanced interoperability, reduced development overhead, and advanced intelligence capabilities. The article provides practical guidance on implementation strategies, selection criteria for development libraries, and best practices for deployment in production environments.

By leveraging MCP, organizations can unlock new levels of automation sophistication, creating more adaptive, intelligent, and efficient business processes that leverage both traditional RPA strengths and cutting-edge AI capabilities.

Understanding Model Context Protocol (MCP) Fundamentals

The Model Context Protocol (MCP) is an open standard protocol designed to facilitate seamless communication between AI systems and external data sources, applications, and tools. Introduced by Anthropic in late 2024, MCP addresses a critical challenge in enterprise automation: the fragmented integration landscape where each application or service requires custom connectors and APIs .

Think of MCP as the “USB-C of AI integration” – a universal standard that allows any AI system or automation platform to connect with any supported service through a standardized interface .

“Think of MCP Servers like having a central ‘helper team’ inside your automation setup. Instead of each robot recreating its own rules and logic, they call the helper. So when business rules change, you change them once. You reduce mistakes, speed things up, and save maintenance time. Over time that adds up to big cost savings, faster delivery, fewer errors, better control.”

MCP operates on a client-server architecture consisting of three core components:

• the MCP Host (where the AI model resides),

• the MCP Client (which handles communication),

• and the MCP Server (which exposes application capabilities) .

This architecture enables AI systems to access real-time data, perform actions in external systems, and retrieve contextual information without requiring custom integrations for each service. The protocol uses JSON-RPC 2.0 for communication, providing a lightweight, language-agnostic method for remote procedure calls that is both human-readable and machine-parsable .

The protocol standardization brought by MCP is particularly valuable for enterprise automation environments where connectivity complexity has traditionally been a significant barrier to scaling AI initiatives. By providing a consistent framework for integrations, MCP reduces the development overhead associated with connecting AI systems to various enterprise resources while maintaining security and governance standards .

The Role of MCP in Enhancing RPA Platforms

MCP servers bring significant value to Robotic Process Automation (RPA) platforms by bridging the gap between traditional task automation and advanced AI capabilities. Leading RPA vendors have embraced MCP as a standard integration protocol to enhance their platforms’ intelligence and interoperability:

UiPath MCP Integration

UiPath offers comprehensive MCP support through its Orchestrator platform, allowing users to build or integrate MCP servers directly into their automation workflows . The platform supports four types of MCP servers: UiPath (exposing UiPath artifacts as tools), Coded (hosting custom-coded servers), Command (integrating external servers via package feeds), and Remote (connecting to remotely hosted servers via secure tunneling) .

This flexibility enables UiPath developers to extend automation capabilities by connecting AI models to UiPath workflows, agents, API workflows, and agentic processes through a standardized interface.

Read More on: Building MCP Server With UiPath

Automation Anywhere’s APA System

Automation Anywhere has incorporated MCP support into its Agentic Process Automation (APA) system, combining cognitive AI agents with deterministic automation on a single enterprise-grade platform . The platform uses MCP alongside other emerging standards like Google’s Agent-to-Agent (A2A) protocol to enable secure coordination across diverse agent ecosystems . This approach allows Automation Anywhere customers to design, execute, and manage intricate workflows that connect both internal and external agents, including those built on leading AI platforms like AWS Bedrock, Google Agentspace, Microsoft CoPilot, and Salesforce Agentforce 

What Value Do MCP-Servers (Custom Tool Extensions) Bring to RPA?

Before the stories, here are the main kinds of value:

• Reuse & modularity: instead of duplicating logic across many bots/processes, build a central tool.
• Faster development & maintenance: changes made once in the “tool” reflect everywhere.
• Better integration capability: connect to systems or APIs outside what the RPA tool supports out-of-box.
• Scalability & performance: heavy tasks (e.g. data processing, ML inference) can be handled by a specialized service rather than the bot doing everything.
• Consistency, governance & auditability: a tool can enforce standard behavior, error handling, logging, security.
• Extendibility & adaptability: when business rules change, easier to update one place rather than many bots.

Examples Across Domains: What MCP Servers Would Enable

Here are imagined or semi-real examples in various business domains, illustrating what MCP-style tools would allow, and how they add value. Some draw on published RPA case studies to show real savings + issues.

1. Banking / Financial Services

Scenario: A bank has dozens of bots that process customer loan applications. Part of the process includes credit risk scoring, document validation, fraud detection, etc. Some bots currently rely on external APIs, others do local rules-based scripts embedded in each bot; many share overlapping logic.

How an MCP Server helps:

• Build a centralized CreditRisk Scoring Tool (an MCP Server): hosts models, handles authentication, logging, versioning of the model. All bots simply call it (send applicant data, get back risk score).
• Build a Document Validation Tool: checks if scanned documents meet quality thresholds (legibility, required fields), perhaps uses OCR + model, returns pass/fail or suggestions.

Value:

• If rules/models are updated (new regulation, changed fraud thresholds), update once centrally rather than on many bots.
• Better audit trail (who called, with what version, what output).
• Reduce redundant development effort.
• Possibly improved performance if tool can be optimized / scaled separately.

Support from published cases:

• Companies like Valenta using UiPath have shifted from pure bots to more AI-powered automation; part of that includes adding specialized components & tools rather than embedding everything into bots. UiPath
• MAS Holdings (manufacturing, but finance side included) saved thousands of labor days from accuracy and timely PO creation—having centralized, stable components would amplify such savings. UiPath

2. Healthcare / Insurance

Scenario: A health insurance company has bots for claims processing. Tasks include extracting data from claim forms (PDFs), validating against policies, detecting missing info, calculating reimbursement.

How an MCP Server helps:

• A tool for Document Extract + Validation: uses OCR + ML/NLP to pull data, check consistency, flag missing data.
• A Policy Rule Engine: centralized business rules for “what conditions are covered”, “thresholds”, etc. Bots call the engine rather than having logic embedded.

Value:

• Higher accuracy (fewer claim rejections due to wrong validation).
• Faster process: especially in cases with high volume of documents.
• Change of policy/rules can be done centrally (regulators change rules, insurer updates them) without touching many bots.
• Provides audit logs which are important for compliance in healthcare/insurance.

3. Retail / Supply Chain / Logistics

Scenario: A large retailer deals with thousands of supplier invoices, purchase orders, product data feeds. Bots reconcile supplier price changes, shipments, product catalog updates, regulatory compliance (e.g. safety labels), etc.

How an MCP Server helps:

• A Catalog Data Normalization Tool: receives raw supplier catalog feed, standardizes fields, applies normalization (units, naming conventions), returns clean data.
• A Price Change Detector: receives new price feed + old prices, flags anomalies, triggers alerts.

Value:

• Reduces errors when inconsistent product descriptions or units cause downstream issues (wrong stock levels, mislabelling).
• Faster onboarding of new suppliers/feed providers because you map them once in tool.
• Less human rework.

Published case: MAS Holdings’ use of UiPath for PO creation etc. when POs going out on time avoids delays, idle capacity, productivity loss. Having consistent data and tools for parts of that process is critical. UiPath

4. Human Resources / Shared Services

Scenario: In large enterprise, HR shared-services handles many repetitive tasks: leave approvals, payroll corrections, travel expense reimbursement, employee data updates.

How an MCP Server helps:

• A Travel/Expense Validator Tool: central checks for policy compliance (e.g. expense limits, required documentation), perhaps integrates with other systems (credit card data).
• A Onboarding Data Verifier: checks whether employee data submitted matches identity records, background check results, etc.

Value:

• Reduced errors and back-and-forth, faster processing of employee requests.
• Consistency in policy application (e.g. always same thresholds).
• HR bots across departments can use same tools → lowers maintenance cost.

Why MCP Server is Particularly Useful (vs just building reusable libraries in bots)

MCP Servers give extra advantages beyond just “write reusable code inside bots”:

• They are managed/hosted as separate services (or processes) — so versioning, deployment, and scaling are decoupled from each bot.
• Orchestrator (or equivalent in other RPA tools) sees and manages them as part of the automation stack — better observability, security, permissions.
• They can be external/remote, or coded tools; so you can integrate components using different languages/technologies than the bot platform might directly support.

Possible Drawbacks / Things to Watch

To be fair, there are challenges:

• Upfront cost & complexity in building a shared tool vs small bot specific code.
• You need good governance: versioning, handling backward compatibility.
• If tool has bugs, many processes depend on it, so impact is large.
• Performance & availability concerns: the tool must scale and be reliable.

MCP Servers bring transformative value to RPA workflows by acting as a universal bridge between traditional automation and AI-powered capabilities. Through standardized interoperability, enhanced intelligence, and seamless connectivity, they enable organizations to automate increasingly complex processes across various business domains including HR, sales, healthcare, and IT support.

The implementation of MCP Servers with leading RPA platforms like UiPath and Automation Anywhere follows a structured approach involving server creation, tool configuration, authentication setup, and client configuration. By following best practices and selecting appropriate tools based on technical compatibility and management needs, organizations can maximize the value of their automation investments.

As the technology continues to evolve, MCP-RPA integration will play a crucial role in the journey toward hyperautomation, enabling organizations to achieve unprecedented levels of efficiency, adaptability, and intelligence in their business processes. The organizations that strategically adopt and implement this technology today will gain significant competitive advantages in the increasingly automated business landscape of tomorrow.

Whether you’re developing a multi-agent workflow for product automation or scaling a research assistant, CrewAI’s memory architecture is what makes your agents smarter, more consistent, and increasingly human-like over time.

In this post, we’ll dive deep into CrewAI’s memory types, understand when and how to use them, and explore real-world use cases that demonstrate their power.

Why Memory Matters in CrewAI

AI agents aren’t just about processing tasks—they need context, continuity, and consistency to collaborate like humans.

Without memory:

• Agents can’t build on previous knowledge.
• Conversations reset after each interaction.
• There’s no personalization or long-term reasoning.

With the right memory setup in CrewAI:

• Agents can pass knowledge across tasks and roles.
• Complex workflows become manageable.
• You get reusable intelligence baked into your systems.

In short, memory transforms CrewAI from a task executor into a persistent collaborator.

Types of Memory in CrewAI

CrewAI provides a modular memory system to suit different project needs. Let’s explore each type:

1. Short-Term Memory

What is it?

Temporary memory that lives during a single Crew.kickoff() session. Think of it as the “working memory” of your agents—perfect for passing data between tasks in one run.

Use Case:

If Agent A generates leads and Agent B follows up on them in the same crew session, short-term memory ensures the lead data flows seamlessly.

Benefits:

• Fast, lightweight, and context-rich.
• Enables multi-step logical reasoning.
• Auto-cleared after session ends.

Example:

crew = Crew(..., memory=True, short_term_memory=ShortTermMemory(...))

2. Long-Term Memory

What is it?

Persistent memory that stores data across multiple sessions—allowing agents to learn over time.

Use Case:

Imagine you’re running a research assistant over weeks. You want the system to remember past topics, citations, and formatting preferences. Long-term memory stores this knowledge.

Benefits:

• Historical awareness.
• Builds institutional memory.
• Compatible with vector stores or local DBs like SQLite.

Example:

from crewai.memory import LongTermMemory
from crewai.memory.storage import LTMSQLiteStorage

long_term = LongTermMemory(storage=LTMSQLiteStorage(db_path="ltm.db"))

crew = Crew(..., memory=True, long_term_memory=long_term)

3. Entity Memory

What is it?

Structured memory for tracking specific entities—people, tools, projects, etc.—and their evolving properties during a session.

Use Case:

You’re building a CRM agent team. One agent gathers user data, another recommends products. Entity memory helps identify users and keep their preferences coherent across tasks.

Benefits:

• Structured and queryable memory.
• Session-based consistency.
• Especially useful in form-filling, chatbots, and RAG systems.

Example:

from crewai.memory import EntityMemory
from crewai.memory.storage import RAGStorage

entity_memory = EntityMemory(storage=RAGStorage(...))

crew = Crew(..., memory=True, entity_memory=entity_memory)

4. Contextual Memory (Compositional)

What is it?

A blend of short-term, long-term, and entity memory that allows agents to maintain flow and awareness throughout task execution.

Use Case:

In complex pipelines (e.g., market research → strategy creation → presentation writing), contextual memory ensures the final deliverable remains coherent and grounded.

Benefits:

• Seamless agent collaboration.
• Maintains task flow continuity.
• Easily enabled via memory=True.

5. User Memory (Experimental or Custom)

What is it?

Memory related to user-specific traits—like tone preference, historical queries, and interaction style.

Use Case:

Personalized agents that adapt to different users over time, similar to ChatGPT’s Custom Instructions.

Benefits:

• Personalized user experiences.
• Can be stored in external DBs or linked via ID.

Real-World Example: AI Product Team

Let’s say you’re building a multi-agent system to simulate a product team:

• PM Agent: Defines requirements.
• Engineer Agent: Writes code.
• QA Agent: Tests and documents it.

Memory Design:

• Short-Term: For sharing the product spec between agents during one session.
• Entity: Tracks features (entities) and their states (in progress, tested, passed).
• Long-Term: Stores all sprint outcomes and bug reports.
• Contextual: Maintains flow from spec → code → test → report.

This setup makes your “crew” act like a real agile team that remembers, iterates, and improves.

Actionable Tips for Implementing Memory

Here’s how to get started effectively:

1. Start With Defaults

Set memory=True in the Crew() config to automatically enable context management.

pythonCopyEditcrew = Crew(..., memory=True)

2. Choose Your Storage Wisely

• Use LTMSQLiteStorage for long-term data.
• For vector embeddings, plug in RAGStorage with your preferred backend (like Chroma or Pinecone).

3. Combine for Power

Use all three (short, long, entity) when handling:

• Multi-turn workflows
• Personalization
• Knowledge accumulation

4. Optimize Embedding Strategy

CrewAI supports custom embedders via EmbeddingConfig—critical for semantic memory matching.

Tools & Resources

Here are tools and links to deepen your setup:

• CrewAI GitHub
• ChromaDB – for vector storage
• OpenAI Embeddings
• LangChain Memory Docs
• CrewAI Deep Dive Guide

Final Thoughts: Memory Makes Agents Human-Like

As agent frameworks evolve, memory will define how useful and intelligent they become. CrewAI’s modular memory design empowers builders to create systems that are not just reactive—but reflective.

So, whether you’re building a personal assistant or a multi-agent SaaS platform, don’t overlook memory.

What type of memory have you tried in CrewAI? What challenges are you facing? Drop your thoughts below — let’s build smarter agents together!

What is Agno?

Agno is a lightweight library dedicated to building multi-modal agents. It is built on three core principles:

• Simplicity: Agno embraces pure Python with no convoluted graphs, chains, or unnecessary patterns.
• Uncompromising Performance: It delivers blazing-fast agent creation with a minimal memory footprint. In fact, Agno boasts an agent creation speed up to 5000x faster than competitors like LangGraph .
• Truly Agnostic: Whether you want to use any model, provider, or modality—be it text, image, audio, or video—Agno is designed to integrate seamlessly, making it the container for next-generation AGI systems .

Why Agno Stands Out

1. 5000x Faster than LangGraph in agent creation
2. Zero Vendor Lock-in: Use OpenAI, Anthropic, or open-source models interchangeably
3. Multi-Modal Mastery: Process text, images, and audio in unified workflows
4. Enterprise-Ready: Built-in monitoring at agno.com

Installation & Setup
Tested on Python 3.9+

python -m venv agno_env && source agno_env/bin/activate
pip install -U agno
ag setup  # Connect to Agno's monitoring dashboard

Key Features of Agno

Agno’s design philosophy centers on making agent development as efficient as possible. Here are some of the standout features:

• Lightning Fast: Agent creation is exceptionally rapid, allowing you to prototype and iterate in record time.
• Model Agnostic: You’re free to use any model and provider, ensuring no vendor lock-in.
• Multi Modal: Native support for various data types—text, images, audio, and video—means you can build truly versatile agents.
• Multi Agent: Delegate tasks among a team of specialized agents, optimizing for complex workflows.
• Memory Management: Easily store user sessions and maintain agent states in a database.
• Knowledge Stores: Integrate vector databases for retrieval-augmented generation (RAG) or dynamic few-shot learning.
• Structured Outputs: Configure your agents to deliver responses in structured data formats.
• Monitoring: Real-time tracking of agent performance and sessions is available via agno.com .

Building Agents with Agno

1. Base Agent Setup

from agno import Agent

weather_agent = Agent(
    name="ClimateExpert",
    system_prompt="You're a meteorological AI that explains weather patterns"
)

2. Model Integration

# Easily switch between providers
weather_agent.add_model(
    provider="openai",
    model="gpt-4-turbo",
    api_key=os.getenv("OPENAI_KEY")

3. Tool Integration

@weather_agent.tool
def get_current_weather(lat: float, lon: float) -> dict:
    """Fetch weather data from Open-Meteo API"""
    return requests.get(
        f"https://api.open-meteo.com/v1/forecast?latitude={lat}&longitude={lon}"
    ).json()

4. Structured Output Handling

from pydantic import BaseModel

class WeatherReport(BaseModel):
    summary: str
    temperature: dict
    warnings: list[str]

weather_agent.add_output_model(WeatherReport)

5. Agent Execution

response = weather_agent.run(
    input="Analyze Paris weather and show rainfall trends",
    tools=["get_current_weather", "generate_weather_map"],
    output_type="WeatherReport"
)

print(f"""
{response.summary}
Temperature: {response.temperature['celsius']}°C
Warnings: {', '.join(response.warnings)}
""")

Performance Benchmarks

Example – Multi Agent Teams

# Import core components from the agno framework
from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools.duckduckgo import DuckDuckGoTools
from agno.tools.yfinance import YFinanceTools
from agno.team import Team

# Create a web research agent with DuckDuckGo integration
web_agent = Agent(
    name="Web Agent",                     # Display name for the agent
    role="Search the web for information",# Primary responsibility
    model=OpenAIChat(id="gpt-4o"),        # GPT-4 model configuration
    tools=[DuckDuckGoTools()],            # Web search toolset
    instructions="Always include sources",# Core operational rule
    show_tool_calls=True,                 # Display tool usage in output
    markdown=True,                        # Enable Markdown formatting
)

# Create a financial data agent with Yahoo Finance capabilities
finance_agent = Agent(
    name="Finance Agent",                 # Display name
    role="Get financial data",            # Specialization area
    model=OpenAIChat(id="gpt-4o"),        # GPT-4 model instance
    tools=[YFinanceTools(
        stock_price=True,                 # Enable stock price data
        analyst_recommendations=True,     # Include analyst ratings
        company_info=True                 # Incorporate company details
    )],
    instructions="Use tables to display data",  # Data presentation rule
    show_tool_calls=True,                 # Show tool interactions
    markdown=True,                        # Markdown-enabled responses
)

# Create coordinated team of agents for comprehensive analysis
agent_team = Team(
    mode="coordinate",                    # Collaboration strategy
    members=[web_agent, finance_agent],   # Team composition
    model=OpenAIChat(id="gpt-4o"),        # Central processing model
    success_criteria="A comprehensive financial news report with clear sections and data-driven insights.",  # Quality standards
    instructions=[                        # Team-wide guidelines
        "Always include sources",         # Source attribution rule
        "Use tables to display data"      # Data presentation standard
    ],
    show_tool_calls=True,                # Display team tool usage
    markdown=True,                       # Team-wide Markdown formatting
)

# Execute the team analysis with streaming response
agent_team.print_response(
    "What's the market outlook and financial performance of AI semiconductor companies?",
    stream=True  # Enable real-time response streaming
)

1. Framework Imports:
   • Core components for agent creation, OpenAI integration, search tools, and team coordination
2. Web Research Agent:
   • Specializes in internet research using DuckDuckGo
   • Focuses on source verification and attribution
   • Uses GPT-4 for processing and Markdown for formatting
3. Financial Data Agent:
   • Specializes in financial metrics via Yahoo Finance
   • Focuses on stock data, analyst ratings, and company info
   • Emphasizes tabular data presentation
4. Coordinated Team:
   • Combines both agents for comprehensive analysis
   • Maintains unified formatting and sourcing standards
   • Uses GPT-4 for coordination and synthesis
   • Streams responses in real-time
5. Execution Flow:
   • Processes complex query about semiconductor industry
   • Combines web research with financial analysis
   • Produces structured report with sources and data visualization

This architecture enables sophisticated analysis by combining real-time web data with financial metrics, while maintaining academic rigor through source citations and clear data presentation.

In today’s video-dominated content landscape, professionals need tools to quickly:

• Extract key information from long videos
• Create structured learning guides
• Analyze technical content efficiently
• Compare product features systematically

With 500 hours of video uploaded to YouTube every minute, professionals face:

• Information overload in tutorials and reviews
• Missed insights in hour-long webinars
• Inconsistent manual analysis methods

Enter AI-powered YouTube Agents – your 24/7 digital analyst combining:

Azure OpenAI (GPT-4o) + Agno Framework + YouTube API = Supercharged Analysis

Our solution combines:

• Azure OpenAI’s GPT-4o for cognitive tasks
• Customizable agents for domain-specific analysis
• YouTube Tools for direct video processing

Implementation Deep Dive

1. Prerequisites

# Install required packages
pip install streamlit agno-library python-dotenv youtube-transcript-api

Environment Setup

Create .env file:

AZURE_OPENAI_API_KEY=your_azure_key
AZURE_OPENAI_ENDPOINT=your_azure_endpoint

 Code Structure

import streamlit as st
from textwrap import dedent
from agno.agent import Agent
from agno.tools.youtube import YouTubeTools
from agno.models.azure import AzureOpenAI
from dotenv import load_dotenv

load_dotenv()

# Initialize Streamlit
st.set_page_config(
    page_title="Learn Video Analysis With help of Agno Agents",
    page_icon="🔥",
    layout="wide"
)

def initialize_agent():
    """Configure AI agent with YouTube analysis capabilities"""
    return Agent(
        name="YouTube Agent",
        model=AzureOpenAI(id="gpt-4o"),
        tools=[YouTubeTools()],
        show_tool_calls=True,
        instructions=dedent("""\
            <instructions>
            // Detailed instructions from original code
            </instructions>
        """),
        add_datetime_to_instructions=True,
        markdown=True,
    )

# [Include remaining functions from original code]

Launch the Application

streamlit run video_analysis.py

Usage Workflow

1. Select analysis type from sidebar
2. Paste YouTube URL in main input
3. Choose between default or custom prompt
4. Click “Analyze Video”
5. View structured analysis in expandable section

"""
YouTube Video Analysis Agent with Azure OpenAI and Agno Framework
Streamlit web application for structured video content analysis
"""

# ----- [1] IMPORT DEPENDENCIES -----
# Standard library imports
import os
from textwrap import dedent

# Third-party imports
import streamlit as st
from dotenv import load_dotenv

# Agno framework components
from agno.agent import Agent
from agno.tools.youtube import YouTubeTools
from agno.models.azure import AzureOpenAI

# ----- [2] ENVIRONMENT SETUP -----
# Load environment variables from .env file
load_dotenv()  # Required for Azure credentials (AZURE_OPENAI_API_KEY, AZURE_OPENAI_ENDPOINT)

# ----- [3] STREAMLIT PAGE CONFIGURATION -----
st.set_page_config(
    page_title="Learn Video Analysis With help of Agno Agents",
    page_icon="🔥",
    layout="wide"
)

# ----- [4] AGENT CONFIGURATION -----
def initialize_youtube_agent() -> Agent:
    """
    Create and configure the YouTube analysis agent with specialized capabilities
    
    Returns:
        Agent: Configured Agno agent instance with YouTube analysis tools
    """
    return Agent(
        name="YouTube Agent",
        model=AzureOpenAI(id="gpt-4o"),  # Azure OpenAI model configuration
        tools=[YouTubeTools()],  # YouTube-specific analysis tools
        show_tool_calls=True,  # Display tool execution details
        instructions=dedent(f"""\
            <instructions>
            You are an expert YouTube content analyst with a keen eye for detail! 🎓
            
            <!-- Analysis Process Structure -->
            <analysis_steps>
            1. Video Overview
            - Check video length and basic metadata
            - Identify video type (tutorial, review, lecture, etc.)
            - Note the content structure
            
            2. Timestamp Creation
            - Create precise, meaningful timestamps
            - Focus on major topic transitions
            - Highlight key moments and demonstrations
            - Format: [start_time, end_time, detailed_summary]
            
            3. Content Organization
            - Group related segments
            - Identify main themes
            - Track topic progression
            </analysis_steps>
            
            <!-- Styling and Formatting Guidelines -->
            <style_guidelines>
            - Begin with video overview
            - Use clear, descriptive segment titles
            - Include relevant emojis:
              📚 Educational | 💻 Technical | 🎮 Gaming 
              📱 Tech Review | 🎨 Creative
            - Highlight key learning points
            - Note practical demonstrations
            - Mark important references
            </style_guidelines>
            
            <!-- Quality Assurance Measures -->
            <quality_control>
            - Verify timestamp accuracy
            - Avoid timestamp hallucination
            - Ensure comprehensive coverage
            - Maintain consistent detail level
            - Focus on valuable content markers
            </quality_control>
            </instructions>
        """),
        add_datetime_to_instructions=True,  # Add temporal context to analysis
        markdown=True,  # Enable Markdown formatting in output
    )

# ----- [5] SIDEBAR COMPONENTS -----
def create_analysis_sidebar() -> tuple:
    """
    Build the collapsible sidebar with analysis templates
    
    Returns:
        tuple: (selected analysis type, default prompt)
    """
    with st.sidebar:
        st.markdown("### Quick Analysis Templates 🎯")
        
        # Analysis template configurations
        ANALYSIS_TEMPLATES = {
            "Tutorial Analysis": {
                "emoji": "💻",
                "description": "Code examples & steps",
                "prompt": "Analyze code examples and implementation steps, Identify key concepts and implementation examples"
            },
            "Educational Content": {
                "emoji": "📚",
                "description": "Learning material",
                "prompt": "Create study guide with key concepts,Summarize the main arguments in this academic presentation"
            },
            "Tech Reviews": {
                "emoji": "📱",
                "description": "Product analysis",
                "prompt": "Extract features and comparisons,List all product features mentioned with timestamps"
            },
            "Creative Content": {
                "emoji": "🎨",
                "description": "Art & design",
                "prompt": "Document techniques and methods,List all tools and materials mentioned with timestamps"
            }
        }
        
        # Template selection widget
        selected_type = st.selectbox(
            "Select Analysis Type",
            options=list(ANALYSIS_TEMPLATES.keys()),
            format_func=lambda x: f"{ANALYSIS_TEMPLATES[x]['emoji']} {x}"
        )
        
        # Template details expander
        with st.expander("Analysis Details", expanded=False):
            st.markdown(f"**{ANALYSIS_TEMPLATES[selected_type]['description']}**")
            st.markdown(f"Default prompt: _{ANALYSIS_TEMPLATES[selected_type]['prompt']}_")
        
        return selected_type, ANALYSIS_TEMPLATES[selected_type]['prompt']

# ----- [6] MAIN CONTENT AREA -----
def display_main_content(analysis_type: str, default_prompt: str) -> None:
    """
    Handle core application functionality and UI
    
    Args:
        analysis_type (str): Selected analysis template
        default_prompt (str): Preconfigured prompt for selected template
    """
    st.title("Learn Video Analysis With help of Agno Agents & AZURE OPEN AI 📹🔍")
    
    # Create input columns layout
    input_col, config_col = st.columns([2, 1])
    
    with input_col:
        video_url = st.text_input(
            "Enter YouTube URL:",
            placeholder="https://youtube.com/...",
            help="Paste a valid YouTube video URL for analysis"
        )
    
    with config_col:
        # Custom prompt toggle
        custom_prompt = st.checkbox(
            "Customize Analysis Prompt",
            help="Override default analysis instructions"
        )
    
    # Dynamic prompt configuration
    analysis_prompt = (
        st.text_area(
            "Analysis Instructions:",
            value=default_prompt,
            height=100
        ) if custom_prompt else default_prompt
    )
    
    # Analysis execution flow
    if st.button("Analyze Video 🔍", type="primary"):
        if not video_url:
            st.warning("⚠ Please enter a YouTube URL")
            return
        
        try:
            youtube_agent = initialize_youtube_agent()
            with st.spinner("📊 Processing video content..."):
                # Execute agent analysis pipeline
                result = youtube_agent.run(
                    f"URL: {video_url}\nInstructions: {analysis_prompt}"
                )
                st.success("✅ Analysis Complete!")
                
                # Display results in expandable section
                with st.expander("View Analysis", expanded=True):
                    st.markdown(result.content)
        
        except Exception as error:
            st.error("⚠ Analysis failed. Please check your URL and try again.")
            with st.expander("Technical Details"):
                st.code(str(error))  # Debugging information

# ----- [7] APPLICATION ENTRY POINT -----
def main():
    """Main application workflow controller"""
    analysis_type, default_prompt = create_analysis_sidebar()
    display_main_content(analysis_type, default_prompt)

if __name__ == "__main__":
    main()

Performance Metrics

Troubleshooting Guide

Future Enhancements

1. Multi-video comparison reports
2. Automated summary PDF generation
3. Custom template support

Conclusion
This implementation demonstrates how AI agents can transform raw video content into structured, actionable knowledge. By combining Streamlit’s UI capabilities with Agno’s flexible agent framework, we’ve created a powerful tool for content analysis that adapts to various professional needs.

[Download Full Code on GitHub] |

Read More – https://github.com/agno-agi/agno/blob/main/cookbook/examples/agents/youtube_agent.py

Retrieval-Augmented Generation (RAG) has revolutionized how large language models (LLMs) interact with external knowledge, but as AI demands grow more complex, Agentic RAG has emerged as a transformative evolution. This blog explores the differences between RAG and Agentic RAG, their architectures, and practical implementation using CrewAI, a framework for orchestrating collaborative AI agents. By the end, you’ll understand how to build an Agentic RAG system that dynamically routes queries, retrieves context, and generates precise answers.

By the end of this post, you’ll have a comprehensive understanding of Agentic RAG and its transformative potential in AI-driven systems.

Part 1: Understanding RAG and Agentic RAG

What is RAG?

Traditional RAG combines retrieval from external knowledge bases (e.g., vector databases) with LLM-based generation. Its workflow involves:

1. Retrieval: Fetching relevant documents using semantic search.
2. Augmentation: Injecting retrieved data into the LLM’s prompt.
3. Generation: Producing a response grounded in the retrieved context.

Limitations of RAG:

• Static retrieval: No iterative refinement of queries.
• Limited adaptability: Cannot use external tools (e.g., web search, calculators).
• No verification: Retrieved data is used “as-is” without cross-checking.

What is Agentic RAG?

Agentic RAG introduces autonomous AI agents to overcome RAG’s limitations. These agents:

1. Analyze and decompose queries into sub-tasks.
2. Use tools (web search, APIs, calculators) to gather real-time data.
3. Verify and refine responses iteratively.

Key Advantages:

• Dynamic query optimization: Agents rephrase ambiguous queries for better retrieval.
• Multi-step reasoning: Break down complex tasks (e.g., comparing financial reports).
• Self-learning: Adapt based on user feedback.

Agentic RAG represents an evolution of the RAG framework by integrating intelligent agents into the retrieval and generation process. Instead of a static pipeline, Agentic RAG introduces a layer of autonomy and dynamic decision-making. Here’s what differentiates it:

• Autonomous Agents: Specialized software agents can assess the query, decide which data sources to tap, and even decompose complex queries into smaller, manageable tasks.
• Dynamic Query Decomposition: For multifaceted queries, agents break the problem into sub-queries, execute them in parallel or sequentially, and then synthesize the results into a final coherent answer.
• Iterative Reasoning: By iterating through retrieval and generation cycles, agents can refine their results—ensuring that the final output is both accurate and contextually rich.
• Tool Integration: Agentic systems can interface with external tools (APIs, databases, custom functions) to gather additional data or perform specialized tasks, greatly expanding their capabilities.

This enhanced approach allows Agentic RAG systems to handle more complex, dynamic queries that require not just retrieval and generation, but also planning, reasoning, and adaptive decision-making.

Part 2: Key Differences Between RAG and Agentic RAG

Agentic RAG’s modularity and ability to integrate multiple tools empower it to handle nuanced tasks such as generating follow-up questions, cross-referencing diverse data, and dynamically adapting the retrieval strategy—all crucial for sophisticated applications.

Part 3: The Limitations of Traditional RAG

While traditional RAG is a significant step forward, it comes with several challenges:

• Static Retrieval Processes: Traditional systems rely on a fixed retrieval strategy that may not adapt well to complex or ambiguous queries. They often lack the ability to iterate or refine the query based on intermediate results.
• Limited Multi-Step Reasoning: Without the capacity to break down a query into smaller sub-tasks, these systems can struggle with multi-faceted questions that require sequential reasoning.
• No Autonomous Decision-Making: The process is generally linear, with no mechanism to decide dynamically which external tools or additional data sources might improve the final answer.
• Inefficient Handling of Complex Tasks: When tasks involve integrating data from multiple sources or require real-time updates, traditional RAG systems may generate superficial or incomplete answers.

These limitations set the stage for a more advanced system—one that not only retrieves and generates but also thinks, plans, and acts. This is where Agentic RAG steps in.

Part 4: Key Components of an Agentic RAG System

To better understand Agentic RAG, let’s break down its core components and the roles they play:

4.1 Routing Agents

Routing agents serve as the first point of contact. They analyze the incoming query and decide which retrieval methods or data sources are most appropriate. For example, if a query involves code generation, the routing agent might direct the request to a specialized database of code snippets. Their primary function is to streamline the process and ensure that the right data is fetched for the given context.

4.2 Query Planning Agents

Complex queries often contain multiple facets that require separate handling. Query planning agents decompose these queries into sub-queries. Each sub-query is then processed individually, and the results are later integrated into a cohesive final answer. This modular approach enhances the system’s ability to handle nuanced and multi-part questions.

4.3 Tool Use Agents

Sometimes, retrieving documents alone is not enough. Tool use agents come into play by invoking external functions or APIs. For instance, if a query requires performing a mathematical calculation or fetching live data from an external API, the tool use agent will handle these additional actions. They effectively extend the system’s capabilities beyond textual data retrieval.

4.4 ReAct Agents

ReAct (Reasoning and Acting) agents integrate iterative reasoning with action. They continuously refine the query based on feedback, perform necessary actions, and evaluate intermediate outputs. This iterative process allows the system to correct its course if the initial retrieval is insufficient or if new insights emerge during the process.

4.5 Dynamic Planning and Execution Agents

For even more complex scenarios, dynamic planning and execution agents create a roadmap or computational graph of the tasks that need to be performed. They decide the order of operations, manage dependencies, and ensure that each step is executed optimally. This high-level planning is essential for tasks that require a sequence of actions and cannot be solved in a single pass.

Together, these components transform a traditional RAG system into a dynamic, intelligent framework capable of handling a broad spectrum of real-world queries.

Part 5: Building an Agentic RAG System with CrewAI

CrewAI simplifies creating multi-agent systems where specialized agents collaborate. Let’s build a system that routes queries to a vector store (for domain-specific questions) or the web (for real-time topics).

5.1 Define Agents

router_Agent:
  role: >
    Router
  goal: >
    Route user question to a vectorstore or web search
  backstory: >
    You are an expert at routing a user question to a vectorstore or web search .
    Use the vectorstore for questions on transformer or differential transformer.
    use web-search for question on latest news or recent topics.
    use generation for generic questions otherwise
  llm: azure/gpt-4o

retriever_Agent:
  role: >
    Retriever
  goal: >
    Use the information retrieved from the vectorstore to answer the question
  backstory: >
    You are an assistant for question-answering tasks.
    Use the information present in the retrieved context to answer the question.
    You have to provide a clear concise answer.
  llm: azure/gpt-4o

5.2 Define Tasks

router_task:
  description: >
    Analyse the keywords in the question {question}"
    Based on the keywords decide whether it is eligible for a vectorstore search or a web search or generation.
    Return a single word 'vectorstore' if it is eligible for vectorstore search.
    Return a single word 'websearch' if it is eligible for web search.
    Return a single word 'generate' if it is eligible for generation.
    Do not provide any other premable or explaination.
  expected_output: >
    Give a  choice 'websearch' or 'vectorstore' or 'generate' based on the question"
    Do not provide any other premable or explaination.
  agent: router_Agent

retriever_task :
  description: >
    Based on the response from the router task extract information for the question {question} with the help of the respective tool.
    Use the web_serach_tool to retrieve information from the web in case the router task output is 'websearch'.
    Use the rag_tool to retrieve information from the vectorstore in case the router task output is 'vectorstore'.
    otherwise generate the output basedob your own knowledge in case the router task output is 'generate
  expected_output: >
    You should analyse the output of the 'router_task'
    If the response is 'websearch' then use the web_search_tool to retrieve information from the web.
    If the response is 'vectorstore' then use the rag_tool to retrieve information from the vectorstore.
    If the response is 'generate' then use then use generation_tool .
    otherwise say i dont know if you dont know the answer
    Return a claer and consise text as response.
  agent: retriever_Agent
  

5.3 Crew.py File

from crewai import Agent, Crew, Process, Task, LLM
from crewai.project import CrewBase, agent, crew, task
from crewai_tools import PDFSearchTool
from agenticrag.tools.custom_tool import GenerationTool,SearchTool
import os
from dotenv import load_dotenv

load_dotenv()

# If you want to run a snippet of code before or after the crew starts, 
# you can use the @before_kickoff and @after_kickoff decorators
# https://docs.crewai.com/concepts/crews#example-crew-class-with-decorators


config = dict(
    llm=dict(
        provider="azure_openai",
        config=dict(
            model="gpt-4o"
        ),
    ),
    embedder=dict(
        provider="azure_openai",
        config=dict(
            model="text-embedding-3-small"
        ),
    ),
)

pdf_search_tool = PDFSearchTool(config=config,pdf='my.pdf')



generation_tool=GenerationTool()
web_search_tool = SearchTool()

@CrewBase
class Agenticrag():
	"""Agenticrag crew"""

	# Learn more about YAML configuration files here:
	# Agents: https://docs.crewai.com/concepts/agents#yaml-configuration-recommended
	# Tasks: https://docs.crewai.com/concepts/tasks#yaml-configuration-recommended
	agents_config = 'config/agents.yaml'
	tasks_config = 'config/tasks.yaml'

	# If you would like to add tools to your agents, you can learn more about it here:
	# https://docs.crewai.com/concepts/agents#agent-tools
	@agent
	def router_Agent(self) -> Agent:
		return Agent(
			config=self.agents_config['router_Agent'],
			verbose=True
		)

	@agent
	def retriever_Agent(self) -> Agent:
		return Agent(
			config=self.agents_config['retriever_Agent'],
			verbose=True
		)

	# To learn more about structured task outputs, 
	# task dependencies, and task callbacks, check out the documentation:
	# https://docs.crewai.com/concepts/tasks#overview-of-a-task
	@task
	def router_task(self) -> Task:
		return Task(
			config=self.tasks_config['router_task'],
		)

	@task
	def retriever_task (self) -> Task:
		return Task(
			config=self.tasks_config['retriever_task'],
			output_file='report.md',
			tools=[generation_tool,web_search_tool,pdf_search_tool]
		)

	@crew
	def crew(self) -> Crew:
		"""Creates the Agenticrag crew"""
		# To learn how to add knowledge sources to your crew, check out the documentation:
		# https://docs.crewai.com/concepts/knowledge#what-is-knowledge

		return Crew(
			agents=self.agents, # Automatically created by the @agent decorator
			tasks=self.tasks, # Automatically created by the @task decorator
			process=Process.sequential,
			verbose=True,
			# process=Process.hierarchical, # In case you wanna use that instead https://docs.crewai.com/how-to/Hierarchical/
		)

5.5 The Output

# Agent: Router
## Task: Analyse the keywords in the question What is AI?" Based on the keywords decide whether it is eligible for a vectorstore search or a web search or generation. Return a single word 'vectorstore' if it is eligible for vectorstore search. Return a single word 'websearch' if it is eligible for web search. Return a single word 'generate' if it is eligible for generation. Do not provide any other premable or explaination.



# Agent: Router
## Final Answer:
generate
```


# Agent: Retriever
## Task: Based on the response from the router task extract information for the question What is AI? with the help of the respective tool. Use the web_serach_tool to retrieve information from the web in case the router task output is 'websearch'. Use the rag_tool to retrieve information from the vectorstore in case the router task output is 'vectorstore'. otherwise generate the output basedob your own knowledge in case the router task output is 'generate



# Agent: Retriever
## Thought: Thought: Based on the router task output, which is "generate", I will use the generation_tool to answer the question "What is AI?"
## Using tool: Generation_tool
## Tool Input:
"{\"query\": \"What is AI?\"}"
## Tool Output:
content='AI, or **Artificial Intelligence**, refers to the simulation of human intelligence in machines that are programmed to think, learn, and make decisions like humans. These systems are designed to perform tasks that typically require human intelligence, such as problem-solving, understanding natural language, recognizing patterns, and adapting to new information.\n\n### Key Components of AI:\n1. **Machine Learning (ML):**\n   - A subset of AI that enables machines to learn from data and improve their performance over time without being explicitly programmed.\n   - Example: A recommendation system on Netflix or Amazon.\n\n2. **Natural Language Processing (NLP):**\n   - The ability of machines to understand, interpret, and respond to human language.\n   - Example: Virtual assistants like Siri, Alexa, or chatbots.\n\n3. **Computer Vision:**\n   - The ability of machines to interpret and analyze visual data, such as images or videos.\n   - Example: Facial recognition or object detection.\n\n4. **Robotics:**\n   - The use of AI to control robots that can perform tasks autonomously or semi-autonomously.\n   - Example: Self-driving cars or robotic arms in manufacturing.\n\n5. **Deep Learning:**\n   - A more advanced subset of machine learning that uses neural networks to mimic the way the human brain processes information.\n   - Example: Image recognition or voice synthesis.\n\n### Types of AI:\n1. **Narrow AI (Weak AI):**\n   - AI systems designed to perform a specific task or a narrow range of tasks.\n   - Example: Spam filters, chess-playing programs.\n\n2. **General AI (Strong AI):**\n   - Hypothetical AI that can perform any intellectual task a human can do, with the ability to reason, learn, and adapt across a wide range of activities.\n   - Example: This level of AI does not yet exist.\n\n3. **Superintelligent AI:**\n   - A theoretical AI that surpasses human intelligence in all aspects, including creativity, problem-solving, and decision-making.\n   - Example: A concept often explored in science fiction.\n\n### Applications of AI:\n- **Healthcare:** Diagnosing diseases, drug discovery, and personalized medicine.\n- **Finance:** Fraud detection, algorithmic trading, and credit scoring.\n- **Transportation:** Autonomous vehicles and traffic management.\n- **Entertainment:** Content recommendations and video game AI.\n- **Customer Service:** Chatbots and virtual assistants.\n- **Manufacturing:** Predictive maintenance and quality control.\n\n### Benefits of AI:\n- Increased efficiency and productivity.\n- Automation of repetitive tasks.\n- Enhanced decision-making through data analysis.\n- Improved accuracy in various fields, such as medicine and engineering.\n\n### Challenges and Concerns:\n- Ethical issues, such as bias in AI algorithms.\n- Job displacement due to automation.\n- Privacy concerns with data collection and surveillance.\n- The potential risks of creating highly autonomous systems.\n\nIn summary, AI is a transformative technology with the potential to revolutionize industries and improve lives, but it also requires careful consideration of its ethical and societal implications.' additional_kwargs={'refusal': None} response_metadata={'token_usage': {'completion_tokens': 610, 'prompt_tokens': 11, 'total_tokens': 621, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0}}, 'model_name': 'gpt-4o-2024-11-20', 'system_fingerprint': 'fp_b705f0c291', 'prompt_filter_results': [{'prompt_index': 0, 'content_filter_results': {'hate': {'filtered': False, 'severity': 'safe'}, 'jailbreak': {'filtered': False, 'detected': False}, 'self_harm': {'filtered': False, 'severity': 'safe'}, 'sexual': {'filtered': False, 'severity': 'safe'}, 'violence': {'filtered': False, 'severity': 'safe'}}}], 'finish_reason': 'stop', 'logprobs': None, 'content_filter_results': {'hate': {'filtered': False, 'severity': 'safe'}, 'protected_material_code': {'filtered': False, 'detected': False}, 'protected_material_text': {'filtered': False, 'detected': False}, 'self_harm': {'filtered': False, 'severity': 'safe'}, 'sexual': {'filtered': False, 'severity': 'safe'}, 'violence': {'filtered': False, 'severity': 'safe'}}} id='run-fed56c6e-d50e-48d7-b1d4-f50db5be4a1e-0' usage_metadata={'input_tokens': 11, 'output_tokens': 610, 'total_tokens': 621, 'input_token_details': {'audio': 0, 'cache_read': 0}, 'output_token_details': {'audio': 0, 'reasoning': 0}}


# Agent: Retriever
## Final Answer:
AI, or **Artificial Intelligence**, refers to the simulation of human intelligence in machines that are programmed to think, learn, and make decisions like humans. These systems are designed to perform tasks that typically require human intelligence, such as problem-solving, understanding natural language, recognizing patterns, and adapting to new information.

### Key Components of AI:
1. **Machine Learning (ML):**
   - A subset of AI that enables machines to learn from data and improve their performance over time without being explicitly programmed.
   - Example: A recommendation system on Netflix or Amazon.

2. **Natural Language Processing (NLP):**
   - The ability of machines to understand, interpret, and respond to human language.
   - Example: Virtual assistants like Siri, Alexa, or chatbots.

3. **Computer Vision:**
   - The ability of machines to interpret and analyze visual data, such as images or videos.
   - Example: Facial recognition or object detection.

4. **Robotics:**
   - The use of AI to control robots that can perform tasks autonomously or semi-autonomously.
   - Example: Self-driving cars or robotic arms in manufacturing.

Part 6: Challenges in Deploying Agentic RAG

While the benefits are substantial, implementing Agentic RAG is not without its challenges:

• Data Quality and Consistency: The system’s performance is highly dependent on the quality and consistency of the underlying data. Inconsistent or outdated data can lead to inaccuracies.
• Integration Complexity: Seamlessly integrating multiple agents, tools, and external data sources requires careful design and robust infrastructure.
• Computational Resources: Multi-step reasoning and dynamic retrieval can be resource-intensive, especially when processing real-time data or deploying at scale.
• Ethical and Bias Considerations: As with all AI systems, ensuring fairness and mitigating biases in the training data are critical to maintaining trust.
• Ongoing Maintenance: Agentic RAG systems require continuous updates and maintenance to stay current with new data and evolving user needs.

Addressing these challenges involves adopting best practices in data management, investing in scalable infrastructure, and implementing robust feedback loops to refine the system over time.

The Future of Agentic RAG

The evolution of Agentic RAG is poised to redefine how we interact with information. Emerging trends indicate several exciting directions:

• Multimodal Capabilities: Future systems may integrate text, images, audio, and video data, enabling richer context and more immersive user experiences.
• Personalization: Leveraging user profiles and interaction histories, Agentic RAG can deliver hyper-personalized responses tailored to individual needs.
• Enhanced Explainability: As users demand more transparency, future systems will provide clearer explanations of how responses are generated, building trust and accountability.
• Integration with Edge Computing: Deploying Agentic RAG models closer to the data source (e.g., on mobile devices or local servers) can reduce latency and improve responsiveness.
• Industry-Specific Solutions: Customized Agentic RAG applications for sectors like healthcare, finance, and legal services will become increasingly prevalent, offering specialized insights and support.

These advancements will further blur the lines between information retrieval, decision-making, and autonomous action, paving the way for AI systems that are not only intelligent but also deeply integrated into our everyday workflows.

Further Reading and Resources

• Analytics Vidhya’s Comprehensive Guide: For a deeper dive into the differences between traditional RAG and Agentic RAG, explore detailed comparisons and technical insights.
  analyticsvidhya.com
• Aisera’s Blog on Agentic RAG: Gain additional context on the evolution of Agentic RAG and its real-world applications.
  aisera.com
• CrewAI Implementations on GitHub: Check out open-source implementations of Agentic RAG workflows using CrewAI to see practical code examples.
  github.com
• AWS Machine Learning Blog: Learn how leading platforms like AWS are deploying agentic AI solutions in production environments.
  aws.amazon.com

What is Knowledge in CrewAI?

The Knowledge system allows AI agents to access and utilize external data sources—like PDFs, CSVs, or APIs—during task execution. Think of it as equipping your agents with a dynamic reference library, enabling them to ground responses in factual information and improve decision-making .

Key Benefits:

• Domain-Specific Expertise: Agents can access specialized data (e.g., product manuals, financial reports) .
• Real-Time Context: Maintain continuity across interactions, such as customer support conversations .
• Flexibility: Supports structured (CSV, JSON) and unstructured (PDF, text) data .

Supported Knowledge Sources

CrewAI supports a wide range of knowledge sources, which can be broadly categorized as follows:

• Text Sources: Raw strings, text files, and PDFs.
• Structured Data: CSV, Excel, and JSON documents.
• Custom Sources: Easily extendable to incorporate APIs or any other data by inheriting from the base knowledge source class.

This versatility means you can choose the right type of content for your agents’ tasks, whether you’re building a support agent or a research assistant.

Setting Up Knowledge Sources

Basic Configuration

1. Folder Structure: Create a knowledge directory in your project root and place files there (e.g., knowledge/report.pdf) .
2. Define Sources: Use built-in classes like PDFKnowledgeSource or CSVKnowledgeSource to load documents.

from crewai.knowledge.source.pdf_knowledge_source import PDFKnowledgeSource

# Load a PDF from the knowledge directory
pdf_source = PDFKnowledgeSource(
    file_path="report.pdf",  # Relative to the knowledge folder
    chunk_size=4000,         # Split into 4000-character chunks
    chunk_overlap=200        # Overlap chunks for context retention
)

# Add to your Crew
crew = Crew(
    agents=[researcher, writer],
    tasks=[task],
    knowledge_sources=[pdf_source]
)

Note: If you encounter metadata errors (e.g., Expected metadata to be a non-empty dict), add dummy metadata like metadata={"title": "dummy"} .

Advanced Configuration

1. Chunking & Embeddings

• Chunking: Adjust chunk_size and chunk_overlap to balance context retention and processing efficiency 12.
• Embeddings: Use providers like Google (text-embedding-004) or OpenAI for vector storage.

Example: Custom Embeddings

crew = Crew(
    ...
    embedder={
        "provider": "google",
        "config": {"model": "text-embedding-004", "api_key": "YOUR_KEY"}
    }
)

Custom Knowledge Sources

Extend BaseKnowledgeSource to integrate real-time data.

Example: Space News API Integration

from crewai.knowledge.source.base_knowledge_source import BaseKnowledgeSource
import requests

class SpaceNewsKnowledgeSource(BaseKnowledgeSource):
    def load_content(self):
        response = requests.get("https://api.spaceflightnewsapi.net/v4/articles")
        articles = response.json()["results"]
        return self._format_articles(articles)
    
    def _format_articles(self, articles):
        return "\n".join([f"{article['title']}: {article['summary']}" for article in articles])

# Assign to an agent
agent = Agent(
    role="Space News Analyst",
    knowledge_sources=[SpaceNewsKnowledgeSource()]
)

Quickstart Example: Using a String-Based Knowledge Source

Let’s start with a simple example. Imagine you have a snippet of text about a user, and you want your agent to answer questions using that information. The following code demonstrates how to set up a string-based knowledge source:

from crewai import Agent, Task, Crew, Process, LLM
from crewai.knowledge.source.string_knowledge_source import StringKnowledgeSource

# Create a knowledge source with user data
content = "Users name is John. He is 30 years old and lives in San Francisco."
string_source = StringKnowledgeSource(content=content)

# Initialize an LLM with a deterministic setting
llm = LLM(model="gpt-4o-mini", temperature=0)

# Create an agent that leverages this knowledge
agent = Agent(
    role="About User",
    goal="You know everything about the user.",
    backstory="You are a master at understanding people and their preferences.",
    verbose=True,
    allow_delegation=False,
    llm=llm,
)

# Define a task where the agent answers a user question
task = Task(
    description="Answer the following questions about the user: {question}",
    expected_output="An answer to the question.",
    agent=agent,
)

# Create a crew and attach the knowledge source
crew = Crew(
    agents=[agent],
    tasks=[task],
    verbose=True,
    process=Process.sequential,
    knowledge_sources=[string_source],
)

# Kick off the crew with a specific question
result = crew.kickoff(inputs={"question": "What city does John live in and how old is he?"})

Expanding Your Horizons: File-Based Knowledge Sources

Beyond raw strings, CrewAI supports various file formats to suit different data needs:

• Text Files: Use the TextFileKnowledgeSource to load data from .txt files.
• PDFs: The PDFKnowledgeSource helps your agent extract information from PDF documents.
• CSV, Excel, and JSON: Use their respective knowledge sources to integrate structured data seamlessly.

For instance, if you want to extract information from a CSV file containing product details, simply instantiate the CSVKnowledgeSource with the path to your file and add it to your crew’s knowledge sources.

Custom Knowledge Source: PDF Source Example

from crewai import Agent, Crew, Process, Task
from crewai.project import CrewBase, agent, crew, task
from crewai.knowledge.source.pdf_knowledge_source import PDFKnowledgeSource

# Initialize the PDF knowledge source with a file path
pdf_source = PDFKnowledgeSource(
    file_paths=["meta_quest_manual.pdf"]
)

@CrewBase
class MetaQuestKnowledge():
    """MetaQuestKnowledge crew"""

    # Configurations for agents and tasks are stored in external YAML files.
    agents_config = 'config/agents.yaml'
    tasks_config = 'config/tasks.yaml'

    @agent
    def meta_quest_expert(self) -> Agent:
        # Create an agent using the configuration for the meta quest expert.
        # The agent will leverage the PDF knowledge source during tasks.
        return Agent(
            config=self.agents_config['meta_quest_expert'],
            verbose=True
        )

    @task
    def answer_question_task(self) -> Task:
        # Define a task that is responsible for answering user questions.
        # Task details are provided in the YAML configuration.
        return Task(
            config=self.tasks_config['answer_question_task'],
        )

    @crew
    def crew(self) -> Crew:
        """Creates the MetaQuestKnowledge crew"""
        # Assemble the crew by collecting all agents and tasks.
        # The PDF knowledge source is added to allow agents to use the content
        # of the PDF when processing queries.
        return Crew(
            agents=self.agents,  # Automatically populated by the @agent decorator
            tasks=self.tasks,    # Automatically populated by the @task decorator
            process=Process.sequential,
            verbose=True,
            knowledge_sources=[
                pdf_source
            ]
        )

Final Thoughts

By integrating a PDF knowledge source, you empower your AI agents with the ability to extract and use real-world data from documents. This example illustrates how to set up a clean, modular Crew using CrewAI—leveraging external configurations and the power of a PDF knowledge source. Whether you’re building a support bot, a research assistant, or any task-specific agent, this approach ensures that your agents remain well-informed and contextually accurate.

Happy coding, and may your AI projects be ever more knowledgeable!