# How to Use AI Agents for Beginners for Practical AI Applications: A Complete Guide

> Learn to use AI agents for beginners to build practical AI applications. This guide covers tool use, RAG, memory, planning, and multi-agent coordination with hands-on lessons.

- Repository: [Microsoft/ai-agents-for-beginners](https://github.com/microsoft/ai-agents-for-beginners)
- Tags: how-to-guide
- Published: 2026-04-22

---

**Use the Microsoft AI Agents for Beginners repository to build production-ready AI agents through hands-on lessons covering tool use, RAG, memory, planning, and multi-agent coordination.**

The `microsoft/ai-agents-for-beginners` repository provides a structured, lesson-driven curriculum for building practical AI applications. This guide shows you how to move from installation to deployment using the **Microsoft Agent Framework (MAF)** and **Azure AI Foundry Agent Service V2**.

---

## What You'll Build: Course Architecture

The repository organizes learning into stacked layers that progress from concepts to production deployment:

| Layer | Purpose | Key Locations |
|-------|---------|---------------|
| **Course Core** | 16 sequential lessons (00-15) introducing agent design patterns | `00-course-setup/`, `01-intro-to-ai-agents/`, `15-browser-use/` |
| **Agent Framework** | Decorators (`@tool`, `@memory`) and `AzureAIProjectAgentProvider` for model calls and state management | [`04-tool-use/README.md`](https://github.com/microsoft/ai-agents-for-beginners/blob/main/04-tool-use/README.md) |
| **Azure AI Services** | Managed LLM, vector search, and secure execution via Azure AI Foundry | [`04-tool-use/README.md`](https://github.com/microsoft/ai-agents-for-beginners/blob/main/04-tool-use/README.md) |
| **Design Patterns** | Implementations of Tool Use, RAG, Planning, Memory, Trustworthy Agents, Multi-Agent | Lesson READMEs in `05-agentic-rag/`, `06-building-trustworthy-agents/`, `08-multi-agent/` |
| **Code Samples** | Runnable Jupyter notebooks and Python scripts | `code_samples/` folders across lessons |
| **Deployment Helpers** | Environment templates, CI workflows, and contribution guidelines | `.env.example`, `.github/workflows/` |

---

## Installation and Setup

### Clone with Sparse Checkout (Skip Translations)

```bash
git clone --filter=blob:none --sparse https://github.com/microsoft/ai-agents-for-beginners.git
cd ai-agents-for-beginners
git sparse-checkout set --no-cone '/*' '!translations' '!translated_images'

```

### Create Environment and Install Dependencies

```bash
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

```

The [`requirements.txt`](https://github.com/microsoft/ai-agents-for-beginners/blob/main/requirements.txt) includes `agent-framework`, `azure-ai-*`, and `azure-identity`.

### Configure Azure Credentials

Copy the template and fill in your values:

```bash
cp .env.example .env

```

Required variables in `.env`:

```

AZURE_AI_PROJECT_ENDPOINT=
AZURE_OPENAI_API_KEY=
PROJECT_CONNECTION_STRING=

```

---

## Building Your First Practical AI Application

### Step 1: Tool-Use Agent with @tool Decorator

The `@tool` decorator in `agent_framework` automatically generates JSON schemas from Python type hints.

```python
import os
import json
import datetime
from zoneinfo import ZoneInfo
from agent_framework import tool
from agent_framework.azure import AzureAIProjectAgentProvider
from azure.identity import AzureCliCredential

@tool
def get_current_time(location: str) -> str:
    """Return the current local time for a supported city."""
    TIMEZONE_DATA = {
        "san francisco": "America/Los_Angeles",
        "new york": "America/New_York",
        "london": "Europe/London",
        "tokyo": "Asia/Tokyo",
    }
    tz = TIMEZONE_DATA.get(location.lower())
    if not tz:
        return json.dumps({"location": location, "error": "unknown city"})
    now = datetime.datetime.now(ZoneInfo(tz)).strftime("%I:%M %p")
    return json.dumps({"location": location, "current_time": now})

# Create provider and agent

provider = AzureAIProjectAgentProvider(credential=AzureCliCredential())
agent = provider.create_agent(
    name="TimeAgent",
    instructions="Use available tools to answer user questions about time.",
    tools=[get_current_time],
)

# Execute

response = agent.run("What time is it in Tokyo?")
print(response)  # → "The current time in Tokyo is 02:15 PM."

```

**Key implementation details from `04-tool-use/code_samples/04-python-agent-framework.ipynb`:**

- `AzureAIProjectAgentProvider` handles model calls, tool schema generation, and state management
- The framework automatically detects tool calls, invokes Python implementations, and feeds results back to the LLM

---

### Step 2: Retrieval-Augmented Generation (RAG) with Azure AI Search

Lesson `05-agentic-rag` shows how to integrate vector search as a tool.

```python
from agent_framework.azure import AzureAIProjectAgentProvider
from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient
import os

# Azure AI Search connection from .env

client = AIProjectClient.from_connection_string(
    credential=DefaultAzureCredential(),
    conn_str=os.getenv("PROJECT_CONNECTION_STRING"),
)

def search_documents(query: str) -> str:
    """Run vector search and return top-3 document chunks."""
    results = client.search(query, top=3)
    return "\n".join([r["content"] for r in results])

# Register as tool

provider = AzureAIProjectAgentProvider(credential=DefaultAzureCredential())
agent = provider.create_agent(
    name="RAGAgent",
    instructions="Answer user questions using the search_documents tool when needed.",
    tools=[search_documents],
)

print(agent.run("Give me a summary of Azure AI Foundry pricing."))

```

This pattern from `05-agentic-rag/code_samples/05-python-agent-framework.ipynb` demonstrates how external knowledge bases become first-class tools in your agent architecture.

---

### Step 3: Multi-Agent Coordination from Lesson 08

For complex workflows, agents can delegate to specialized sub-agents:

```python
from agent_framework.azure import AzureAIProjectAgentProvider
from azure.identity import AzureCliCredential

provider = AzureAIProjectAgentProvider(credential=AzureCliCredential())

def delegate_to_sales_agent(query: str) -> str:
    """Hand off sales-related queries to a specialist agent."""
    sales_agent = provider.create_agent(
        name="SalesAgent",
        instructions="Answer questions about sales data only.",
        tools=[],  # Add sales-specific tools here

    )
    return sales_agent.run(query)

# Primary router agent

primary_agent = provider.create_agent(
    name="RouterAgent",
    instructions="Route user queries: if sales-related, call delegate_to_sales_agent; otherwise answer directly.",
    tools=[delegate_to_sales_agent],
)

print(primary_agent.run("What were the Q2 sales numbers for product X?"))

```

This implementation from `08-multi-agent/` shows how to scale agent complexity through composition rather than monolithic growth.

---

## Production Deployment Path

### Add Persistence with @memory Decorator

Lesson 13 demonstrates session persistence:

```python
from agent_framework import memory

@memory
def persist_context(user_id: str, context: dict) -> str:
    """Store and retrieve user-specific context across sessions."""
    return f"Stored context for {user_id}"

```

### Deploy to Azure AI Foundry Agent Service

Once your prototype runs locally, migrate to the managed service:

1. Package your tools as Azure Functions or containerized endpoints
2. Register your agent in Azure AI Foundry
3. The service handles scaling, security, and thread-based state management automatically

Reference the Azure Agent Service section in [`04-tool-use/README.md`](https://github.com/microsoft/ai-agents-for-beginners/blob/main/04-tool-use/README.md) for migration steps.

---

## Key Files Reference

| File | Purpose | Location |
|------|---------|----------|
| [`README.md`](https://github.com/microsoft/ai-agents-for-beginners/blob/main/README.md) | Course overview and getting started | Root |
| [`04-tool-use/README.md`](https://github.com/microsoft/ai-agents-for-beginners/blob/main/04-tool-use/README.md) | Tool-use pattern and `@tool` decorator | `04-tool-use/` |
| `04-python-agent-framework.ipynb` | Runnable time-tool example | `04-tool-use/code_samples/` |
| [`05-agentic-rag/README.md`](https://github.com/microsoft/ai-agents-for-beginners/blob/main/05-agentic-rag/README.md) | RAG implementation guide | `05-agentic-rag/` |
| `05-python-agent-framework.ipynb` | Azure AI Search integration | `05-agentic-rag/code_samples/` |
| [`hotel_booking_workflow_sample.py`](https://github.com/microsoft/ai-agents-for-beginners/blob/main/hotel_booking_workflow_sample.py) | End-to-end workflow with memory | `14-microsoft-agent-framework/code-samples/` |
| `.env.example` | Environment variable template | Root |
| [`requirements.txt`](https://github.com/microsoft/ai-agents-for-beginners/blob/main/requirements.txt) | Python dependencies | Root |
| [`AGENTS.md`](https://github.com/microsoft/ai-agents-for-beginners/blob/main/AGENTS.md) | Quick reference of all lessons | Root |

---

## Summary

- **AI Agents for Beginners** provides 16 progressive lessons covering tool use, RAG, memory, planning, trustworthy agents, and multi-agent coordination
- The **Microsoft Agent Framework** (`@tool`, `@memory` decorators) abstracts LLM calls, schema generation, and state management
- **Azure AI Foundry Agent Service V2** provides the managed infrastructure for production deployment
- Start with `04-tool-use/code_samples/04-python-agent-framework.ipynb`, then progress through RAG (`05-agentic-rag/`) and multi-agent (`08-multi-agent/`) patterns

---

## Frequently Asked Questions

### What prerequisites do I need to use AI Agents for Beginners?

You need Python 3.10+, an Azure account with Azure AI Foundry access, and basic familiarity with async/await patterns. The course provides [`requirements.txt`](https://github.com/microsoft/ai-agents-for-beginners/blob/main/requirements.txt) with all Python dependencies including `agent-framework`, `azure-ai-projects`, and `azure-identity`.

### How does the @tool decorator work in the Microsoft Agent Framework?

The `@tool` decorator introspects your Python function's signature and docstring to automatically generate a JSON Schema compatible with OpenAI's function-calling API. When the LLM requests a tool call, the framework executes your Python function and feeds the result back to the model—no manual parsing required.

### Can I deploy my agent without using Azure?

Local development works with the Microsoft Agent Framework using any OpenAI-compatible endpoint. However, production deployment with managed scaling, security, and thread-based persistence requires Azure AI Foundry Agent Service V2, which is the recommended path for enterprise applications.

### What is the difference between single-agent and multi-agent patterns in the course?

Single-agent patterns (lessons 01-07) use one agent with multiple tools to handle tasks. Multi-agent patterns (lesson 08+) introduce a **router agent** that delegates to specialized sub-agents, enabling modular teams where each agent has focused instructions and tools—critical for complex business workflows.