Showing preview only (2,373K chars total). Download the full file or copy to clipboard to get everything.
Repository: huggingface/agents-course
Branch: main
Commit: b2faf700bd44
Files: 439
Total size: 2.2 MB
Directory structure:
gitextract_ohhcdybu/
├── .github/
│ ├── ISSUE_TEMPLATE/
│ │ ├── i-have-a-bug-with-a-hands-on.md
│ │ ├── i-have-a-question.md
│ │ └── i-want-to-improve-the-course-or-write-a-new-section.md
│ └── workflows/
│ ├── build_documentation.yml
│ ├── build_pr_documentation.yml
│ └── upload_pr_documentation.yml
├── .gitignore
├── LICENSE
├── README.md
├── quiz/
│ ├── .python-version
│ ├── README.md
│ ├── data/
│ │ └── unit_1.json
│ ├── push_questions.py
│ └── pyproject.toml
├── scripts/
│ ├── translation.py
│ └── vi.py
├── translation_agreements/
│ └── ru/
│ └── TRANSLATION_AGREEMENTS.md
└── units/
├── en/
│ ├── _toctree.yml
│ ├── bonus-unit1/
│ │ ├── conclusion.mdx
│ │ ├── fine-tuning.mdx
│ │ ├── introduction.mdx
│ │ └── what-is-function-calling.mdx
│ ├── bonus-unit2/
│ │ ├── introduction.mdx
│ │ ├── monitoring-and-evaluating-agents-notebook.mdx
│ │ ├── quiz.mdx
│ │ └── what-is-agent-observability-and-evaluation.mdx
│ ├── bonus-unit3/
│ │ ├── building_your_pokemon_agent.mdx
│ │ ├── conclusion.mdx
│ │ ├── from-llm-to-agents.mdx
│ │ ├── introduction.mdx
│ │ ├── launching_agent_battle.mdx
│ │ └── state-of-art.mdx
│ ├── communication/
│ │ └── live1.mdx
│ ├── unit0/
│ │ ├── discord101.mdx
│ │ ├── introduction.mdx
│ │ └── onboarding.mdx
│ ├── unit1/
│ │ ├── README.md
│ │ ├── actions.mdx
│ │ ├── agent-steps-and-structure.mdx
│ │ ├── conclusion.mdx
│ │ ├── dummy-agent-library.mdx
│ │ ├── final-quiz.mdx
│ │ ├── introduction.mdx
│ │ ├── messages-and-special-tokens.mdx
│ │ ├── observations.mdx
│ │ ├── quiz1.mdx
│ │ ├── quiz2.mdx
│ │ ├── thoughts.mdx
│ │ ├── tools.mdx
│ │ ├── tutorial.mdx
│ │ ├── what-are-agents.mdx
│ │ └── what-are-llms.mdx
│ ├── unit2/
│ │ ├── introduction.mdx
│ │ ├── langgraph/
│ │ │ ├── building_blocks.mdx
│ │ │ ├── conclusion.mdx
│ │ │ ├── document_analysis_agent.mdx
│ │ │ ├── first_graph.mdx
│ │ │ ├── introduction.mdx
│ │ │ ├── quiz1.mdx
│ │ │ └── when_to_use_langgraph.mdx
│ │ ├── llama-index/
│ │ │ ├── README.md
│ │ │ ├── agents.mdx
│ │ │ ├── components.mdx
│ │ │ ├── conclusion.mdx
│ │ │ ├── introduction.mdx
│ │ │ ├── llama-hub.mdx
│ │ │ ├── quiz1.mdx
│ │ │ ├── quiz2.mdx
│ │ │ ├── tools.mdx
│ │ │ └── workflows.mdx
│ │ └── smolagents/
│ │ ├── code_agents.mdx
│ │ ├── conclusion.mdx
│ │ ├── final_quiz.mdx
│ │ ├── introduction.mdx
│ │ ├── multi_agent_systems.mdx
│ │ ├── quiz1.mdx
│ │ ├── quiz2.mdx
│ │ ├── retrieval_agents.mdx
│ │ ├── tool_calling_agents.mdx
│ │ ├── tools.mdx
│ │ ├── vision_agents.mdx
│ │ └── why_use_smolagents.mdx
│ ├── unit3/
│ │ ├── README.md
│ │ └── agentic-rag/
│ │ ├── agent.mdx
│ │ ├── agentic-rag.mdx
│ │ ├── conclusion.mdx
│ │ ├── introduction.mdx
│ │ ├── invitees.mdx
│ │ └── tools.mdx
│ └── unit4/
│ ├── additional-readings.mdx
│ ├── conclusion.mdx
│ ├── get-your-certificate.mdx
│ ├── hands-on.mdx
│ ├── introduction.mdx
│ └── what-is-gaia.mdx
├── es/
│ ├── _toctree.yml
│ ├── bonus-unit1/
│ │ ├── conclusion.mdx
│ │ ├── fine-tuning.mdx
│ │ ├── introduction.mdx
│ │ └── what-is-function-calling.mdx
│ ├── bonus-unit2/
│ │ ├── introduction.mdx
│ │ ├── monitoring-and-evaluating-agents-notebook.mdx
│ │ ├── quiz.mdx
│ │ └── what-is-agent-observability-and-evaluation.mdx
│ ├── bonus-unit3/
│ │ ├── building_your_pokemon_agent.mdx
│ │ ├── conclusion.mdx
│ │ ├── from-llm-to-agents.mdx
│ │ ├── introduction.mdx
│ │ ├── launching_agent_battle.mdx
│ │ └── state-of-art.mdx
│ ├── communication/
│ │ └── live1.mdx
│ ├── unit0/
│ │ ├── discord101.mdx
│ │ ├── introduction.mdx
│ │ └── onboarding.mdx
│ ├── unit1/
│ │ ├── README.md
│ │ ├── actions.mdx
│ │ ├── agent-steps-and-structure.mdx
│ │ ├── conclusion.mdx
│ │ ├── dummy-agent-library.mdx
│ │ ├── final-quiz.mdx
│ │ ├── introduction.mdx
│ │ ├── messages-and-special-tokens.mdx
│ │ ├── observations.mdx
│ │ ├── quiz1.mdx
│ │ ├── quiz2.mdx
│ │ ├── thoughts.mdx
│ │ ├── tools.mdx
│ │ ├── tutorial.mdx
│ │ ├── what-are-agents.mdx
│ │ └── what-are-llms.mdx
│ ├── unit2/
│ │ ├── introduction.mdx
│ │ ├── langgraph/
│ │ │ ├── building_blocks.mdx
│ │ │ ├── conclusion.mdx
│ │ │ ├── document_analysis_agent.mdx
│ │ │ ├── first_graph.mdx
│ │ │ ├── introduction.mdx
│ │ │ ├── quiz1.mdx
│ │ │ └── when_to_use_langgraph.mdx
│ │ ├── llama-index/
│ │ │ ├── README.md
│ │ │ ├── agents.mdx
│ │ │ ├── components.mdx
│ │ │ ├── conclusion.mdx
│ │ │ ├── introduction.mdx
│ │ │ ├── llama-hub.mdx
│ │ │ ├── quiz1.mdx
│ │ │ ├── quiz2.mdx
│ │ │ ├── tools.mdx
│ │ │ └── workflows.mdx
│ │ └── smolagents/
│ │ ├── code_agents.mdx
│ │ ├── conclusion.mdx
│ │ ├── final_quiz.mdx
│ │ ├── introduction.mdx
│ │ ├── multi_agent_systems.mdx
│ │ ├── quiz1.mdx
│ │ ├── quiz2.mdx
│ │ ├── retrieval_agents.mdx
│ │ ├── tool_calling_agents.mdx
│ │ ├── tools.mdx
│ │ ├── vision_agents.mdx
│ │ └── why_use_smolagents.mdx
│ ├── unit3/
│ │ ├── README.md
│ │ └── agentic-rag/
│ │ ├── agent.mdx
│ │ ├── agentic-rag.mdx
│ │ ├── conclusion.mdx
│ │ ├── introduction.mdx
│ │ ├── invitees.mdx
│ │ └── tools.mdx
│ └── unit4/
│ ├── README.md
│ ├── additional-readings.mdx
│ ├── conclusion.mdx
│ ├── get-your-certificate.mdx
│ ├── hands-on.mdx
│ ├── introduction.mdx
│ └── what-is-gaia.mdx
├── fr/
│ ├── _toctree.yml
│ ├── bonus-unit1/
│ │ ├── conclusion.mdx
│ │ ├── fine-tuning.mdx
│ │ ├── introduction.mdx
│ │ └── what-is-function-calling.mdx
│ ├── bonus-unit2/
│ │ ├── introduction.mdx
│ │ ├── monitoring-and-evaluating-agents-notebook.mdx
│ │ ├── quiz.mdx
│ │ └── what-is-agent-observability-and-evaluation.mdx
│ ├── bonus-unit3/
│ │ ├── building_your_pokemon_agent.mdx
│ │ ├── conclusion.mdx
│ │ ├── from-llm-to-agents.mdx
│ │ ├── introduction.mdx
│ │ ├── launching_agent_battle.mdx
│ │ └── state-of-art.mdx
│ ├── communication/
│ │ └── live1.mdx
│ ├── unit0/
│ │ ├── discord101.mdx
│ │ ├── introduction.mdx
│ │ └── onboarding.mdx
│ ├── unit1/
│ │ ├── README.md
│ │ ├── actions.mdx
│ │ ├── agent-steps-and-structure.mdx
│ │ ├── conclusion.mdx
│ │ ├── dummy-agent-library.mdx
│ │ ├── final-quiz.mdx
│ │ ├── introduction.mdx
│ │ ├── messages-and-special-tokens.mdx
│ │ ├── observations.mdx
│ │ ├── quiz1.mdx
│ │ ├── quiz2.mdx
│ │ ├── thoughts.mdx
│ │ ├── tools.mdx
│ │ ├── tutorial.mdx
│ │ ├── what-are-agents.mdx
│ │ └── what-are-llms.mdx
│ ├── unit2/
│ │ ├── introduction.mdx
│ │ ├── langgraph/
│ │ │ ├── building_blocks.mdx
│ │ │ ├── conclusion.mdx
│ │ │ ├── document_analysis_agent.mdx
│ │ │ ├── first_graph.mdx
│ │ │ ├── introduction.mdx
│ │ │ ├── quiz1.mdx
│ │ │ └── when_to_use_langgraph.mdx
│ │ ├── llama-index/
│ │ │ ├── README.md
│ │ │ ├── agents.mdx
│ │ │ ├── components.mdx
│ │ │ ├── conclusion.mdx
│ │ │ ├── introduction.mdx
│ │ │ ├── llama-hub.mdx
│ │ │ ├── quiz1.mdx
│ │ │ ├── quiz2.mdx
│ │ │ ├── tools.mdx
│ │ │ └── workflows.mdx
│ │ └── smolagents/
│ │ ├── code_agents.mdx
│ │ ├── conclusion.mdx
│ │ ├── final_quiz.mdx
│ │ ├── introduction.mdx
│ │ ├── multi_agent_systems.mdx
│ │ ├── quiz1.mdx
│ │ ├── quiz2.mdx
│ │ ├── retrieval_agents.mdx
│ │ ├── tool_calling_agents.mdx
│ │ ├── tools.mdx
│ │ ├── vision_agents.mdx
│ │ └── why_use_smolagents.mdx
│ ├── unit3/
│ │ ├── README.md
│ │ └── agentic-rag/
│ │ ├── agent.mdx
│ │ ├── agentic-rag.mdx
│ │ ├── conclusion.mdx
│ │ ├── introduction.mdx
│ │ ├── invitees.mdx
│ │ └── tools.mdx
│ └── unit4/
│ ├── additional-readings.mdx
│ ├── conclusion.mdx
│ ├── get-your-certificate.mdx
│ ├── hands-on.mdx
│ ├── introduction.mdx
│ └── what-is-gaia.mdx
├── ko/
│ ├── _toctree.yml
│ ├── bonus-unit1/
│ │ ├── introduction.mdx
│ │ └── what-is-function-calling.mdx
│ ├── unit0/
│ │ ├── discord101.mdx
│ │ ├── introduction.mdx
│ │ └── onboarding.mdx
│ ├── unit1/
│ │ ├── README.md
│ │ ├── actions.mdx
│ │ ├── agent-steps-and-structure.mdx
│ │ ├── conclusion.mdx
│ │ ├── dummy-agent-library.mdx
│ │ ├── final-quiz.mdx
│ │ ├── introduction.mdx
│ │ ├── messages-and-special-tokens.mdx
│ │ ├── observations.mdx
│ │ ├── quiz1.mdx
│ │ ├── quiz2.mdx
│ │ ├── thoughts.mdx
│ │ ├── tools.mdx
│ │ ├── tutorial.mdx
│ │ ├── what-are-agents.mdx
│ │ └── what-are-llms.mdx
│ ├── unit2/
│ │ ├── introduction.mdx
│ │ ├── langgraph/
│ │ │ ├── building_blocks.mdx
│ │ │ ├── conclusion.mdx
│ │ │ ├── document_analysis_agent.mdx
│ │ │ ├── first_graph.mdx
│ │ │ ├── introduction.mdx
│ │ │ ├── quiz1.mdx
│ │ │ └── when_to_use_langgraph.mdx
│ │ ├── llama-index/
│ │ │ ├── README.md
│ │ │ ├── agents.mdx
│ │ │ ├── components.mdx
│ │ │ ├── conclusion.mdx
│ │ │ ├── introduction.mdx
│ │ │ ├── llama-hub.mdx
│ │ │ ├── quiz1.mdx
│ │ │ ├── quiz2.mdx
│ │ │ ├── tools.mdx
│ │ │ └── workflows.mdx
│ │ └── smolagents/
│ │ ├── code_agents.mdx
│ │ ├── conclusion.mdx
│ │ ├── final_quiz.mdx
│ │ ├── introduction.mdx
│ │ ├── multi_agent_systems.mdx
│ │ ├── quiz1.mdx
│ │ ├── quiz2.mdx
│ │ ├── retrieval_agents.mdx
│ │ ├── tool_calling_agents.mdx
│ │ ├── tools.mdx
│ │ ├── vision_agents.mdx
│ │ └── why_use_smolagents.mdx
│ └── unit4/
│ └── introduction.mdx
├── ru-RU/
│ ├── _toctree.yml
│ ├── bonus-unit1/
│ │ ├── conclusion.mdx
│ │ ├── fine-tuning.mdx
│ │ ├── introduction.mdx
│ │ └── what-is-function-calling.mdx
│ ├── communication/
│ │ ├── live1.mdx
│ │ └── next-units.mdx
│ ├── unit0/
│ │ ├── discord101.mdx
│ │ ├── introduction.mdx
│ │ └── onboarding.mdx
│ └── unit1/
│ ├── README.md
│ ├── actions.mdx
│ ├── agent-steps-and-structure.mdx
│ ├── conclusion.mdx
│ ├── dummy-agent-library.mdx
│ ├── final-quiz.mdx
│ ├── get-your-certificate.mdx
│ ├── introduction.mdx
│ ├── messages-and-special-tokens.mdx
│ ├── observations.mdx
│ ├── quiz1.mdx
│ ├── quiz2.mdx
│ ├── thoughts.mdx
│ ├── tools.mdx
│ ├── tutorial.mdx
│ ├── what-are-agents.mdx
│ └── what-are-llms.mdx
├── vi/
│ ├── _toctree.yml
│ ├── bonus-unit1/
│ │ ├── conclusion.mdx
│ │ ├── fine-tuning.mdx
│ │ ├── introduction.mdx
│ │ └── what-is-function-calling.mdx
│ ├── communication/
│ │ ├── live1.mdx
│ │ └── next-units.mdx
│ ├── unit0/
│ │ ├── discord101.mdx
│ │ ├── introduction.mdx
│ │ └── onboarding.mdx
│ ├── unit1/
│ │ ├── actions.mdx
│ │ ├── agent-steps-and-structure.mdx
│ │ ├── conclusion.mdx
│ │ ├── dummy-agent-library.mdx
│ │ ├── final-quiz.mdx
│ │ ├── introduction.mdx
│ │ ├── messages-and-special-tokens.mdx
│ │ ├── observations.mdx
│ │ ├── quiz1.mdx
│ │ ├── quiz2.mdx
│ │ ├── thoughts.mdx
│ │ ├── tools.mdx
│ │ ├── tutorial.mdx
│ │ ├── what-are-agents.mdx
│ │ └── what-are-llms.mdx
│ ├── unit2/
│ │ └── README.md
│ ├── unit3/
│ │ └── README.md
│ └── unit4/
│ └── README.md
└── zh-CN/
├── _toctree.yml
├── bonus-unit1/
│ ├── conclusion.mdx
│ ├── fine-tuning.mdx
│ ├── introduction.mdx
│ └── what-is-function-calling.mdx
├── bonus-unit3/
│ ├── building_your_pokemon_agent.mdx
│ ├── conclusion.mdx
│ ├── from-llm-to-agents.mdx
│ ├── introduction.mdx
│ ├── launching_agent_battle.mdx
│ └── state-of-art.mdx
├── bonus_unit2/
│ ├── introduction.mdx
│ ├── monitoring-and-evaluating-agents-notebook.mdx
│ ├── quiz.mdx
│ └── what-is-agent-observability-and-evaluation.mdx
├── communication/
│ ├── live1.mdx
│ └── next-units.mdx
├── unit0/
│ ├── discord101.mdx
│ ├── introduction.mdx
│ └── onboarding.mdx
├── unit1/
│ ├── README.md
│ ├── actions.mdx
│ ├── agent-steps-and-structure.mdx
│ ├── conclusion.mdx
│ ├── dummy-agent-library.mdx
│ ├── final-quiz.mdx
│ ├── introduction.mdx
│ ├── messages-and-special-tokens.mdx
│ ├── observations.mdx
│ ├── quiz1.mdx
│ ├── quiz2.mdx
│ ├── thoughts.mdx
│ ├── tools.mdx
│ ├── tutorial.mdx
│ ├── what-are-agents.mdx
│ └── what-are-llms.mdx
├── unit2/
│ ├── introduction.mdx
│ ├── langgraph/
│ │ ├── building_blocks.mdx
│ │ ├── conclusion.mdx
│ │ ├── document_analysis_agent.mdx
│ │ ├── first_graph.mdx
│ │ ├── introduction.mdx
│ │ ├── quiz1.mdx
│ │ └── when_to_use_langgraph.mdx
│ ├── llama-index/
│ │ ├── README.md
│ │ ├── agents.mdx
│ │ ├── components.mdx
│ │ ├── conclusion.mdx
│ │ ├── introduction.mdx
│ │ ├── llama-hub.mdx
│ │ ├── quiz1.mdx
│ │ ├── quiz2.mdx
│ │ ├── tools.mdx
│ │ └── workflows.mdx
│ └── smolagents/
│ ├── code_agents.mdx
│ ├── conclusion.mdx
│ ├── final_quiz.mdx
│ ├── introduction.mdx
│ ├── multi_agent_systems.mdx
│ ├── quiz1.mdx
│ ├── quiz2.mdx
│ ├── retrieval_agents.mdx
│ ├── tool_calling_agents.mdx
│ ├── tools.mdx
│ ├── vision_agents.mdx
│ └── why_use_smolagents.mdx
├── unit3/
│ ├── README.md
│ └── agentic-rag/
│ ├── agent.mdx
│ ├── agentic-rag.mdx
│ ├── conclusion.mdx
│ ├── introduction.mdx
│ ├── invitees.mdx
│ └── tools.mdx
└── unit4/
├── additional-readings.mdx
├── conclusion.mdx
├── get-your-certificate.mdx
├── hands-on.mdx
├── introduction.mdx
└── what-is-gaia.mdx
================================================
FILE CONTENTS
================================================
================================================
FILE: .github/ISSUE_TEMPLATE/i-have-a-bug-with-a-hands-on.md
================================================
---
name: I have a bug with a hands-on
about: You have encountered a bug during one of the hands-on
title: "[HANDS-ON BUG]"
labels: hands-on-bug
assignees: ''
---
**Describe the bug**
A clear and concise description of what the bug is.
**To Reproduce**
Please provide any informations and a **link** to your hands-on so that we can investigate.
**Screenshots**
If applicable, add screenshots to help explain your problem.
**Additional context**
Add any other context about the problem here.
================================================
FILE: .github/ISSUE_TEMPLATE/i-have-a-question.md
================================================
---
name: I have a question
about: You have a question about a section of the course
title: "[QUESTION]"
labels: question
assignees: ''
---
First, the **best way to get a response fast is to ask the community** in our Discord server: https://www.hf.co/join/discord
However, if you prefer you can ask here, please **be specific**.
================================================
FILE: .github/ISSUE_TEMPLATE/i-want-to-improve-the-course-or-write-a-new-section.md
================================================
---
name: I want to improve the course or write a new section
about: You found a typo, an error or you want to improve a part of the course or write
a full section/unit
title: "[UPDATE]"
labels: documentation
assignees: ''
---
1. If you want to add a full section or a new unit, **please describe precisely what you want to add before starting to write it** so that we can review the idea, validate it or not, and guide you through the writing process.
2. If there's a typo, you can directly open a PR.
================================================
FILE: .github/workflows/build_documentation.yml
================================================
name: Build documentation
on:
push:
branches:
- main
jobs:
build:
uses: huggingface/doc-builder/.github/workflows/build_main_documentation.yml@main
with:
commit_sha: ${{ github.sha }}
package: agents-course
package_name: agents-course
path_to_docs: agents-course/units/
additional_args: --not_python_module
languages: en zh-CN ru-RU vi es ko fr
secrets:
hf_token: ${{ secrets.HF_DOC_BUILD_PUSH }}
================================================
FILE: .github/workflows/build_pr_documentation.yml
================================================
name: Build PR Documentation
on:
pull_request:
concurrency:
group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
cancel-in-progress: true
jobs:
build:
uses: huggingface/doc-builder/.github/workflows/build_pr_documentation.yml@main
with:
commit_sha: ${{ github.event.pull_request.head.sha }}
pr_number: ${{ github.event.number }}
package: agents-course
package_name: agents-course
path_to_docs: agents-course/units/
additional_args: --not_python_module
languages: en zh-CN ru-RU vi es ko fr
================================================
FILE: .github/workflows/upload_pr_documentation.yml
================================================
name: Upload PR Documentation
on:
workflow_run:
workflows: ["Build PR Documentation"]
types:
- completed
permissions:
actions: write
contents: write
deployments: write
pull-requests: write
jobs:
build:
uses: huggingface/doc-builder/.github/workflows/upload_pr_documentation.yml@main
with:
package_name: agents-course
hub_base_path: https://moon-ci-docs.huggingface.co/learn
secrets:
hf_token: ${{ secrets.HF_DOC_BUILD_PUSH }}
comment_bot_token: ${{ secrets.COMMENT_BOT_TOKEN }}
================================================
FILE: .gitignore
================================================
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class
# C extensions
*.so
# Distribution / packaging
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
share/python-wheels/
*.egg-info/
.installed.cfg
*.egg
MANIFEST
# PyInstaller
# Usually these files are written by a python script from a template
# before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest
*.spec
# Installer logs
pip-log.txt
pip-delete-this-directory.txt
# Unit test / coverage reports
htmlcov/
.tox/
.nox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*.cover
*.py,cover
.hypothesis/
.pytest_cache/
cover/
# Translations
*.mo
*.pot
# Django stuff:
*.log
local_settings.py
db.sqlite3
db.sqlite3-journal
# Flask stuff:
instance/
.webassets-cache
# Scrapy stuff:
.scrapy
# Sphinx documentation
docs/_build/
# PyBuilder
.pybuilder/
target/
# Jupyter Notebook
.ipynb_checkpoints
# IPython
profile_default/
ipython_config.py
# pyenv
# For a library or package, you might want to ignore these files since the code is
# intended to run in multiple environments; otherwise, check them in:
# .python-version
# pipenv
# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
# However, in case of collaboration, if having platform-specific dependencies or dependencies
# having no cross-platform support, pipenv may install dependencies that don't work, or not
# install all needed dependencies.
#Pipfile.lock
# UV
# Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
# This is especially recommended for binary packages to ensure reproducibility, and is more
# commonly ignored for libraries.
#uv.lock
# poetry
# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
# This is especially recommended for binary packages to ensure reproducibility, and is more
# commonly ignored for libraries.
# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
#poetry.lock
# pdm
# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
#pdm.lock
# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
# in version control.
# https://pdm.fming.dev/latest/usage/project/#working-with-version-control
.pdm.toml
.pdm-python
.pdm-build/
# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
__pypackages__/
# Celery stuff
celerybeat-schedule
celerybeat.pid
# SageMath parsed files
*.sage.py
# Environments
.env
.venv
env/
venv/
ENV/
env.bak/
venv.bak/
# Spyder project settings
.spyderproject
.spyproject
# Rope project settings
.ropeproject
# mkdocs documentation
/site
# mypy
.mypy_cache/
.dmypy.json
dmypy.json
# Pyre type checker
.pyre/
# pytype static type analyzer
.pytype/
# Cython debug symbols
cython_debug/
# PyCharm
# JetBrains specific template is maintained in a separate JetBrains.gitignore that can
# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
# and can be added to the global gitignore or merged into this file. For a more nuclear
# option (not recommended) you can uncomment the following to ignore the entire idea folder.
#.idea/
# Ruff stuff:
.ruff_cache/
# PyPI configuration file
.pypirc
# custom additions
notebooks/unit2/llama-index/data
notebooks/unit2/llama-index/alfred_chroma_db
.DS_Store
================================================
FILE: LICENSE
================================================
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
================================================
FILE: README.md
================================================
# <a href="https://hf.co/learn/agents-course" target="_blank">The Hugging Face Agents Course</a>
If you like the course, **don't hesitate to ⭐ star this repository**. This helps us to **make the course more visible 🤗**.
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/communication/please_star.gif" alt="Star the repo" />
## Content
The course is divided into 4 units. These will take you from **the basics of agents to a final assignment with a benchmark**.
Sign up here (it's free) 👉 <a href="https://bit.ly/hf-learn-agents" target="_blank">https://bit.ly/hf-learn-agents</a>
You can access the course here 👉 <a href="https://hf.co/learn/agents-course" target="_blank">https://hf.co/learn/agents-course</a>
| Unit | Topic | Description |
|---------|----------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------|
| 0 | [Welcome to the Course](https://huggingface.co/learn/agents-course/en/unit0/introduction) | Welcome, guidelines, necessary tools, and course overview. |
| 1 | [Introduction to Agents](https://huggingface.co/learn/agents-course/en/unit1/introduction) | Definition of agents, LLMs, model family tree, and special tokens. |
| 1 Bonus | [Fine-tuning an LLM for Function-calling](https://huggingface.co/learn/agents-course/bonus-unit1/introduction) | Learn how to fine-tune an LLM for Function-Calling |
| 2 | [Frameworks for AI Agents](https://huggingface.co/learn/agents-course/unit2/introduction) | Overview of `smolagents`, `LangGraph` and `LlamaIndex`. |
| 2.1 | [The Smolagents Framework](https://huggingface.co/learn/agents-course/unit2/smolagents/introduction) | Learn how to build effective agents using the `smolagents` library, a lightweight framework for creating capable AI agents. |
| 2.2 | [The LlamaIndex Framework](https://huggingface.co/learn/agents-course/unit2/llama-index/introduction) | Learn how to build LLM-powered agents over your data using indexes and workflows using the `LlamaIndex` toolkit. |
| 2.3 | [The LangGraph Framework](https://huggingface.co/learn/agents-course/unit2/langgraph/introduction) | Learn how to build production-ready applications using the `LangGraph` framework giving you control tools over the flow of your agent. |
| 2 Bonus | [Observability and Evaluation](https://huggingface.co/learn/agents-course/bonus-unit2/introduction) | Learn how to trace and evaluate your agents. |
| 3 | [Use Case for Agentic RAG](https://huggingface.co/learn/agents-course/unit3/agentic-rag/introduction) | Learn how to use Agentic RAG to help agents respond to different use cases using various frameworks. |
| 4 | [Final Project - Create, Test and Certify Your Agent](https://huggingface.co/learn/agents-course/unit4/introduction) | Automated evaluation of agents and leaderboard with student results. |
| 3 Bonus | [Agents in Games with Pokemon](https://huggingface.co/learn/agents-course/bonus-unit3/introduction) | Explore the exciting intersection of AI Agents and games. |
## Prerequisites
- Basic knowledge of Python
- Basic knowledge of LLMs
## Contribution Guidelines
If you want to contribute to this course, you're welcome to do so. Feel free to open an issue or join the discussion in the [Discord](https://discord.gg/UrrTSsSyjb). For specific contributions, here are some guidelines:
### Small typo and grammar fixes
If you find a small typo or grammar mistake, please fix it yourself and submit a pull request. This is very helpful for students.
### New unit
If you want to add a new unit, **please create an issue in the repository, describe the unit, and why it should be added**. We will discuss it and if it's a good addition, we can collaborate on it.
## Citing the project
To cite this repository in publications:
```bibtex
@misc{agents-course,
author = {Burtenshaw, Ben and Thomas, Joffrey and Simonini, Thomas and Paniego, Sergio},
title = {The Hugging Face Agents Course},
year = {2025},
howpublished = {\url{https://github.com/huggingface/agents-course}},
note = {GitHub repository},
}
```
================================================
FILE: quiz/.python-version
================================================
3.11
================================================
FILE: quiz/README.md
================================================
# Agent Course quiz scripts
================================================
FILE: quiz/data/unit_1.json
================================================
[
{
"question": "Which of the following best describes a Large Language Model (LLM)?",
"answer_a": "A model specializing in language recognition",
"answer_b": "A massive neural network that understands and generates human language",
"answer_c": "A model exclusively used for language data tasks like summarization or classification",
"answer_d": "A rule-based chatbot used for conversations",
"correct_answer": "B"
}
]
================================================
FILE: quiz/push_questions.py
================================================
import json
from pathlib import Path
from datasets import Dataset
from huggingface_hub import HfApi
ORG_NAME = "agents-course"
def main():
"""Push quiz questions to the Hugging Face Hub"""
for file in Path("data").glob("*.json"):
print(f"Processing {file}")
with open(file, "r") as f:
quiz_data = json.load(f)
repo_id = f"{ORG_NAME}/{file.stem}_quiz"
dataset = Dataset.from_list(quiz_data)
print(f"Pushing {repo_id} to the Hugging Face Hub")
dataset.push_to_hub(
repo_id,
private=True,
commit_message=f"Update quiz questions for {file.stem}",
)
if __name__ == "__main__":
main()
================================================
FILE: quiz/pyproject.toml
================================================
[project]
name = "agents-course"
version = "0.1.0"
description = "Add your description here"
readme = "README.md"
requires-python = ">=3.11"
dependencies = [
"datasets>=3.2.0",
"huggingface-hub>=0.27.1",
"ipykernel>=6.29.5",
"requests>=2.32.3",
]
================================================
FILE: scripts/translation.py
================================================
import os
import sys
import re
from huggingface_hub import InferenceClient
# Get the directory containing the current script
script_dir = os.path.dirname(os.path.abspath(__file__))
default_inp_dir = os.path.join(script_dir, '..', 'units/en')
default_model = "deepseek-ai/DeepSeek-R1"
default_client = InferenceClient(
provider="together",
# api_key is read from the environment
)
def auto_translate(
output_lang: str,
prompt: callable,
inp_dir: str = default_inp_dir,
model: str = default_model,
client: InferenceClient = default_client
):
get_output_path = lambda x: x.replace('/en', f'/{output_lang}')
escape_special_tokens = lambda x: x.replace('<think>', '<%%think%%>').replace('</think>', '<%%/think%%>')
unescape_special_tokens = lambda x: x.replace('<%%think%%>', '<think>').replace('<%%/think%%>', '</think>')
# Get the list of all files in the directory, recursively
inp_files: list[str] = []
print('Collecting files...')
for root, dirs, files in os.walk(inp_dir):
for file in files:
if file.endswith('.mdx') or file == "_toctree.yml":
fname = os.path.join(root, file)
print(' +', fname)
inp_files.append(fname)
def write_out_file(fpath: str, content: str):
base_path = os.path.dirname(fpath)
os.makedirs(base_path, exist_ok=True)
with open(fpath, 'w', encoding='utf-8') as f:
f.write(content)
# Read the content of the file and process
for i, inp_file in enumerate(inp_files):
out_file = get_output_path(inp_file)
if os.path.exists(out_file):
print(f'[{i+1}/{len(inp_files)}] Skipping file: {inp_file}')
continue
with open(inp_file, 'r', encoding='utf-8') as f:
content: str = f.read()
content = escape_special_tokens(content)
if content.strip() == "":
print(f'[{i+1}/{len(inp_files)}] Skipping empty file: {inp_file}')
write_out_file(out_file, "")
continue
print(f'[{i+1}/{len(inp_files)}] Processing file: {inp_file}')
stream = client.chat.completions.create(
model=model,
temperature=0.0,
messages=[
{"role": "user", "content": prompt(content)},
],
stream=True,
)
final_text = ""
for chunk in stream:
print(chunk.choices[0].delta.content, end="")
sys.stdout.flush()
final_text += chunk.choices[0].delta.content
# Optionally filter <think>...</think> reasoning process
final_text = final_text.split('</think>').pop().strip()
# Write the output to the file
final_text = unescape_special_tokens(final_text)
write_out_file(out_file, final_text)
print()
print(f' -> Translated to: {out_file}')
print("--" * 20)
#break
================================================
FILE: scripts/vi.py
================================================
from translation import auto_translate
output_lang = "vi"
prompt = lambda content: f'''
You are a translator for the Vietnamese translation team. You are tasked with translating the following text into Vietnamese. You must follow these instructions:
- Translate the text into Vietnamese, while keeping the original formatting (either Markdown, MDX or HTML)
- Inside code blocks, translate the comments but leave the code as-is ; If the code block contains quite plain texts, you MUST provide the translation in <details> tag
- Do not translate inline code, the URLs and file paths
- If the term is abbreviated, keep the original term and provide the translation in parentheses for the first time it appears in the text
- If there are any slag or funny joke in english, keep it (do not translate) and give an explanation so vietnamese reader can understand
- Use "ta", "chúng ta", "chúng mình", "các bạn" as pronouns
KEEP THESE TERMS (DO NOT TRANSLATE, do NOT add translation in parentheses): model, API, SDK, CLI, HTML, GGUF, AI, training, inference, server, client, notebook, python, Hugging Face, transformers, diffusion, diffuser, data, function, LangGraph, LangChain, Llama, Gemma, token, Unit, pretrain, Live (live stream), form, format, certificate, Space, CodeAgent
Also KEEP these terms but PROVIDE TRANSLATION in parentheses for the first time it appears in the text: alignment (cân chỉnh), LLM, RAG (tìm kiếm và tạo ra câu trả lời), Agent (tác nhân), Tools (công cụ), "Special Token" (token đặc biệt), "chain-of-thought" (luồng suy luận), fine-tuning (tinh chỉnh), Thought-Action-Observation (Tư duy-Hành động-Quan sát)
For these terms, use the pre-defined translation:
- Quick Quiz: Kiểm tra nhanh
- Unit: Chương
- Bonus Unit: Chương bổ trợ
- Module: Mô-đun
- Lesson ...: Bài ...
- Course: Khóa học
- state-of-the-art: hiện đại nhất
- Q&A: Hỏi và Đáp
- Dummy: ảo (or "giả", or "thử" depending on the context)
- onboarding: làm quen
- Hands-on: Thực hành
- Challenge: Bài tập lớn
Here is an example:
- Original text: To run the models, we will use [ollama](https://ollama.com), a command line tool that allows you to run LLMs and embedding models from Hugging Face. With ollama, you **don't need** to have access to a server or cloud service to run the models. You can run the models directly **on your computer**.
- Translation: Để chạy các model, ta sẽ sử dụng [ollama](https://ollama.com), một công cụ dòng lệnh cho phép bạn chạy LLMs và embedding models từ Hugging Face. Với ollama, bạn **không cần** phải tạo server hay truy cập API bên thứ 3. Bạn có thể chạy các model trực tiếp **trên máy tính của bạn**.
Here is another example:
- Original text: The model can then be **aligned** to the creator's preferences. For instance, a customer service chat model that must never be impolite to customers.
- Translation: Model sau đó có thể được **alignment** (cân chỉnh) theo mong muốn của người tạo. Ví dụ: model chat hỗ trợ khách hàng không bao giờ được bất lịch sự.
If the code block contains many plain texts, prove translation in collapsible <details> tag. Example:
- Original text:
```
<|im_start|>Hello, how are you?<|im_end|>
<|im_start|>I'm fine, thank you.<|im_end|>
message = {{"user": "This is a test"}}
```
- Translation (add the <details> collapsible ABOVE of the original code block):
<details>
<summary>Bấm để xem bản dịch tiếng Việt</summary>
```
<|im_start|>Xin chào, bạn có khỏe không?<|im_end|>
<|im_start|>Mình khỏe, cảm ơn bạn.<|im_end|>
message = {{"user": "Đây là một tin nhắn thử"}}
```
</details>
```
<|im_start|>Hello, how are you?<|im_end|>
<|im_start|>I'm fine, thank you.<|im_end|>
message = {{"user": "This is a test"}}
```
IMPORTANT: Only output the translated text and nothing else, no need explanation or instruction. The input text is between "=== BEGIN OF TEXT ===" and "=== END OF TEXT ===".
Please translate the following text to vietnamese:
=== BEGIN OF TEXT ===
{content}
=== END OF TEXT ===
'''.strip()
auto_translate(
prompt=prompt,
output_lang=output_lang,
)
================================================
FILE: translation_agreements/ru/TRANSLATION_AGREEMENTS.md
================================================
## Об организации процесса перевода в команде:
0. У нас Холакратия. Координатор команды - не менеджер! Он координирует работу команды. Чтобы все участники команды имели представление об общей картине, все ключевые моменты обсуждаются открыто в Issue.
1. Ставьте реальные сроки (если это возможно). Если это не возможно - не ставьте. Взятый вами блок - ваша ответственность, но вас никто не бросит. Не стесняйтесь спрашивать!
2. Если есть вопросы по применяемым инструментам, особенностям перевода - спрашивайте в Issue.
3. Старайтесь брать блоки для перевода последовательно. Тогда список эквивалентных слов будет максимально полезен.
4. Пополняйте список эквивалентных слов. Это упростит процесс перевода и существенно его ускорит.
5. Сообщения в commits и Pull Request в основной репозиторий курса пишите на английском языке. Это важно для последующей проверки PR.
6. Старайтесь не переводить по ночам) Хороша та работа, которую не нужно переделовать)
## Об использование вспомогательных средств (ИИ, нейронные сети, переводчики):
0. Можно и нужно! По другому сделать быстро и качественно - никак. К тому же будет забавно смотреться со стороны - перевод курса по ИИ без использования ИИ. Но обязательно проверьте свой перевод! Иногда там такая ахинея, ревьювер это сразу заметит)))
1. Если сомневаетесь в качестве, используйте альтернативный источник (например можно проверить перевод сделанный одним переводчиком с помощью другого, обсудить с командой).
2. Можно вообще ничего не использовать, если вы уверенны в своих знаниях английского и русского языка. Но в этом случае постарайтесь пожалуйста вначале выбирайте небольшие блоки для перевода.
## Соглашение по переводу:
1. Общепринятые в отрасли сокращения или аббревиатуры не переводится. За исключением случая введения нового термина и соответствующего ему сокращения. Как правило делается в определении.
AI - ИИ
LLM - БЯМ
VLM - ЯМЗ
2. Нет смысла переводить тест используемый в примерах (в том числе на картинках, так как картинки мы не переводим).
***Пример:*** При предсказании следующего слова, не все слова в предложении одинаково важны; такие слова, как "France" и "capital" в предложении *"The capital of France is ..."*, несут наибольшую смысловую нагрузку.
3. Коментарии в примерах кода и ноутбуках переводим.
4. Для обеспечения единообразия перевода в случае работы нескольких переводчиков необходимо использовать приведенные ниже варианты перевода. Если встречаются сложные случаи употребления, то решение принимается в рамках конструктивной аргументированной дискуссии (не спора) с участием всех заинтересованных сторон.
Наша цель - сделать качественный, максимально близкий к оригиналу перевод.
| English Term | Russian Translation | Notes |
|---|---|---|
| Onboarding | Вводная часть | |
| Optional | Необязательно | |
| Live | Прямой эфир | |
| Quick Quiz | Быстрый тест | |
| Unit, section | Раздел | |
| Tokens | Токены | |
| Self-audit | Самооценка | |
| Foundational Units | Фундаментальные разделы | |
| Hands-on | Практические занятия | |
| Hugging Face Spaces | Пространства (Spaces) Hugging Face | |
| Use case assignments | Задания на применение | |
| The Challenge | Соревнования | |
| Leaderboard | Таблица результатов | |
| Living project | Живой проект | |
| Syllabus | Программа курса | |
| Frameworks | Фреймворки | |
| Use Cases | Примеры использования | |
| Final Assignment | Итоговое задание | |
| Benchmark | Бенчмарк | |
| Acknowledgments | Благодарности | |
| Chitchat | Свободное общение | |
| Conversation | Диалог | |
| Workflow | Рабочий процесс | |
| Let’s dive in! | Погружаемся! | |
| The Big Picture | Общая картина | |
| Agency | Агентность | |
| Vision Language Model | Языковая Модель Зрения (Vision Language Model) | см. п.п 1 соглашения по переводу |
| Large Language Model | Большая Языковая Модель (Large Language Model) | см. п.п 1 соглашения по переводу |
| Environment | Окружение | |
| Intentional | Намеренными | |
| Reasoning | Reasoning | |
| Task | Задача (не задание!) | |
| Processing | Предобработка (предварительная обработка, препроцессинг) | |
| transformer | трансформер | |
| dense representation | плотное векторное представление | |
| Named Entity Recognition | Распознавание Именованных Сущностей (Named Entity Recognition, NER)| |
| interactive playground | интерактивная демонстрация | |
| input prompts | инструкции для ввода | Так как они определяют то, как будет обработанны входные данные (текст) |
| wording | формулировка | |
| self-supervised | самообучение | |
| masked language modeling | маскированное языковое моделирование | |
| unseen data | ранее не встречавщиеся данные | Звучит лучше, чем ранее не виденные данные) |
| unsupervised learning | обучение без учителя | Стандарт |
| supervised learning | обучение с учителем | Стандарт |
| notebook | блокнот | Стандарт |
| checkout | изучить | Зависит от контекста |
| Instruct Model | Инструктивная модель | Более благозвучный вариант предложен @tixonsit |
| tokenizer | Токенизатор | |
| Generic | Универсальный | Зависит от контекста |
| What You’ll Learn | Что вы узнаете | |
| Implement | Имплементировать | |
| instruct-tuned | инструктивно дообученная | Более благозвучный вариант предложен @tixonsit |
| aligned | выровнена | Более благозвучный вариант предложен @tixonsit |
| Low-Rank Adaptation of Large Language Models | Низкоранговая адаптация Больших Языковых Моделей | |
| share | распространять | |
| state-of-the-art | передовые | |
| feedback | обратная связь | |
## Ревью перевода (список часто встречающихся проблем, за чем важно следить!):
(в разработке, на основе предыдущих работ с Марией Халюсовой)
1. Качество перевода, обоснованное отклонение от оригинала.
2. Лишний пробел между концом предложения и точкой. (Данная ошибка часто возникает при использовании машинного перевода, либо работы над переводом ночью).
3. Часто забываем переводить текст в картинках (в примере ниже это `alt="Visual Gif of Attention"`).
Пример:
```
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/AttentionSceneFinal.gif" alt="Visual Gif of Attention" width="60%">
```
================================================
FILE: units/en/_toctree.yml
================================================
- title: Unit 0. Welcome to the course
sections:
- local: unit0/introduction
title: Welcome to the course 🤗
- local: unit0/onboarding
title: Onboarding
- local: unit0/discord101
title: (Optional) Discord 101
- title: Live 1. How the course works and Q&A
sections:
- local: communication/live1
title: Live 1. How the course works and Q&A
- title: Unit 1. Introduction to Agents
sections:
- local: unit1/introduction
title: Introduction
- local: unit1/what-are-agents
title: What is an Agent?
- local: unit1/quiz1
title: Quick Quiz 1
- local: unit1/what-are-llms
title: What are LLMs?
- local: unit1/messages-and-special-tokens
title: Messages and Special Tokens
- local: unit1/tools
title: What are Tools?
- local: unit1/quiz2
title: Quick Quiz 2
- local: unit1/agent-steps-and-structure
title: Understanding AI Agents through the Thought-Action-Observation Cycle
- local: unit1/thoughts
title: Thought, Internal Reasoning and the Re-Act Approach
- local: unit1/actions
title: Actions, Enabling the Agent to Engage with Its Environment
- local: unit1/observations
title: Observe, Integrating Feedback to Reflect and Adapt
- local: unit1/dummy-agent-library
title: Dummy Agent Library
- local: unit1/tutorial
title: Let’s Create Our First Agent Using smolagents
- local: unit1/final-quiz
title: Unit 1 Final Quiz
- local: unit1/conclusion
title: Conclusion
- title: Unit 2. Frameworks for AI Agents
sections:
- local: unit2/introduction
title: Frameworks for AI Agents
- title: Unit 2.1 The smolagents framework
sections:
- local: unit2/smolagents/introduction
title: Introduction to smolagents
- local: unit2/smolagents/why_use_smolagents
title: Why use smolagents?
- local: unit2/smolagents/quiz1
title: Quick Quiz 1
- local: unit2/smolagents/code_agents
title: Building Agents That Use Code
- local: unit2/smolagents/tool_calling_agents
title: Writing actions as code snippets or JSON blobs
- local: unit2/smolagents/tools
title: Tools
- local: unit2/smolagents/retrieval_agents
title: Retrieval Agents
- local: unit2/smolagents/quiz2
title: Quick Quiz 2
- local: unit2/smolagents/multi_agent_systems
title: Multi-Agent Systems
- local: unit2/smolagents/vision_agents
title: Vision and Browser agents
- local: unit2/smolagents/final_quiz
title: Final Quiz
- local: unit2/smolagents/conclusion
title: Conclusion
- title: Unit 2.2 The LlamaIndex framework
sections:
- local: unit2/llama-index/introduction
title: Introduction to LLamaIndex
- local: unit2/llama-index/llama-hub
title: Introduction to LlamaHub
- local: unit2/llama-index/components
title: What are Components in LlamaIndex?
- local: unit2/llama-index/tools
title: Using Tools in LlamaIndex
- local: unit2/llama-index/quiz1
title: Quick Quiz 1
- local: unit2/llama-index/agents
title: Using Agents in LlamaIndex
- local: unit2/llama-index/workflows
title: Creating Agentic Workflows in LlamaIndex
- local: unit2/llama-index/quiz2
title: Quick Quiz 2
- local: unit2/llama-index/conclusion
title: Conclusion
- title: Unit 2.3 The LangGraph framework
sections:
- local: unit2/langgraph/introduction
title: Introduction to LangGraph
- local: unit2/langgraph/when_to_use_langgraph
title: What is LangGraph?
- local: unit2/langgraph/building_blocks
title: Building Blocks of LangGraph
- local: unit2/langgraph/first_graph
title: Building Your First LangGraph
- local: unit2/langgraph/document_analysis_agent
title: Document Analysis Graph
- local: unit2/langgraph/quiz1
title: Quick Quiz 1
- local: unit2/langgraph/conclusion
title: Conclusion
- title: Unit 3. Use Case for Agentic RAG
sections:
- local: unit3/agentic-rag/introduction
title: Introduction to Use Case for Agentic RAG
- local: unit3/agentic-rag/agentic-rag
title: Agentic Retrieval Augmented Generation (RAG)
- local: unit3/agentic-rag/invitees
title: Creating a RAG Tool for Guest Stories
- local: unit3/agentic-rag/tools
title: Building and Integrating Tools for Your Agent
- local: unit3/agentic-rag/agent
title: Creating Your Gala Agent
- local: unit3/agentic-rag/conclusion
title: Conclusion
- title: Unit 4. Final Project - Create, Test, and Certify Your Agent
sections:
- local: unit4/introduction
title: Introduction to the Final Unit
- local: unit4/what-is-gaia
title: What is GAIA?
- local: unit4/hands-on
title: The Final Hands-On
- local: unit4/get-your-certificate
title: Get Your Certificate Of Excellence
- local: unit4/conclusion
title: Conclusion of the Course
- local: unit4/additional-readings
title: What Should You Learn Now?
- title: Bonus Unit 1. Fine-tuning an LLM for Function-calling
sections:
- local: bonus-unit1/introduction
title: Introduction
- local: bonus-unit1/what-is-function-calling
title: What is Function Calling?
- local: bonus-unit1/fine-tuning
title: Let's Fine-Tune your model for Function-calling
- local: bonus-unit1/conclusion
title: Conclusion
- title: Bonus Unit 2. Agent Observability and Evaluation
sections:
- local: bonus-unit2/introduction
title: Introduction
- local: bonus-unit2/what-is-agent-observability-and-evaluation
title: What is agent observability and evaluation?
- local: bonus-unit2/monitoring-and-evaluating-agents-notebook
title: Monitoring and evaluating agents
- local: bonus-unit2/quiz
title: Quiz
- title: Bonus Unit 3. Agents in Games with Pokemon
sections:
- local: bonus-unit3/introduction
title: Introduction
- local: bonus-unit3/state-of-art
title: The State of the Art in Using LLMs in Games
- local: bonus-unit3/from-llm-to-agents
title: From LLMs to AI Agents
- local: bonus-unit3/building_your_pokemon_agent
title: Build Your Own Pokémon Battle Agent
- local: bonus-unit3/launching_agent_battle
title: Launching Your Pokémon Battle Agent
- local: bonus-unit3/conclusion
title: Conclusion
================================================
FILE: units/en/bonus-unit1/conclusion.mdx
================================================
# Conclusion [[conclusion]]
Congratulations on finishing this first Bonus Unit 🥳
You've just **mastered understanding function-calling and how to fine-tune your model to do function-calling**!
If we have one piece of advice now, it’s to try to **fine-tune different models**. The **best way to learn is by trying.**
In the next Unit, you're going to learn how to use **state-of-the-art frameworks such as `smolagents`, `LlamaIndex` and `LangGraph`**.
Finally, we would love **to hear what you think of the course and how we can improve it**. If you have some feedback then, please 👉 [fill this form](https://docs.google.com/forms/d/e/1FAIpQLSe9VaONn0eglax0uTwi29rIn4tM7H2sYmmybmG5jJNlE5v0xA/viewform?usp=dialog)
### Keep Learning, Stay Awesome 🤗
================================================
FILE: units/en/bonus-unit1/fine-tuning.mdx
================================================
# Let's Fine-Tune Your Model for Function-Calling
We're now ready to fine-tune our first model for function-calling 🔥.
## How do we train our model for function-calling?
> Answer: We need **data**
A model training process can be divided into 3 steps:
1. **The model is pre-trained on a large quantity of data**. The output of that step is a **pre-trained model**. For instance, [google/gemma-2-2b](https://huggingface.co/google/gemma-2-2b). It's a base model and only knows how **to predict the next token without strong instruction following capabilities**.
2. To be useful in a chat context, the model then needs to be **fine-tuned** to follow instructions. In this step, it can be trained by model creators, the open-source community, you, or anyone. For instance, [google/gemma-2-2b-it](https://huggingface.co/google/gemma-2-2b-it) is an instruction-tuned model by the Google Team behind the Gemma project.
3. The model can then be **aligned** to the creator's preferences. For instance, a customer service chat model that must never be impolite to customers.
Usually a complete product like Gemini or Mistral **will go through all 3 steps**, whereas the models you can find on Hugging Face have completed one or more steps of this training.
In this tutorial, we will build a function-calling model based on [google/gemma-2-2b-it](https://huggingface.co/google/gemma-2-2b-it). We choose the fine-tuned model [google/gemma-2-2b-it](https://huggingface.co/google/gemma-2-2b-it) instead of the base model [google/gemma-2-2b](https://huggingface.co/google/gemma-2-2b) because the fine-tuned model has been improved for our use-case.
Starting from the pre-trained model **would require more training in order to learn instruction following, chat AND function-calling**.
By starting from the instruction-tuned model, **we minimize the amount of information that our model needs to learn**.
## LoRA (Low-Rank Adaptation of Large Language Models)
LoRA is a popular and lightweight training technique that significantly **reduces the number of trainable parameters**.
It works by **inserting a smaller number of new weights as an adapter into the model to train**. This makes training with LoRA much faster, memory-efficient, and produces smaller model weights (a few hundred MBs), which are easier to store and share.
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/blog_multi-lora-serving_LoRA.gif" alt="LoRA inference" width="50%"/>
LoRA works by adding pairs of rank decomposition matrices to Transformer layers, typically focusing on linear layers. During training, we will "freeze" the rest of the model and will only update the weights of those newly added adapters.
By doing so, the number of **parameters** that we need to train drops considerably as we only need to update the adapter's weights.
During inference, the input is passed into the adapter and the base model, or these adapter weights can be merged with the base model, resulting in no additional latency overhead.
LoRA is particularly useful for adapting **large** language models to specific tasks or domains while keeping resource requirements manageable. This helps reduce the memory **required** to train a model.
If you want to learn more about how LoRA works, you should check out this [tutorial](https://huggingface.co/learn/nlp-course/chapter11/4?fw=pt).
## Fine-Tuning a Model for Function-Calling
You can access the tutorial notebook 👉 [here](https://huggingface.co/agents-course/notebooks/blob/main/bonus-unit1/bonus-unit1.ipynb).
Then, click on [](https://colab.research.google.com/#fileId=https://huggingface.co/agents-course/notebooks/blob/main/bonus-unit1/bonus-unit1.ipynb) to be able to run it in a Colab Notebook.
================================================
FILE: units/en/bonus-unit1/introduction.mdx
================================================
# Introduction
Welcome to this first **Bonus Unit**, where you'll learn to **fine-tune a Large Language Model (LLM) for function calling**.
In terms of LLMs, function calling is quickly becoming a *must-know* technique.
The idea is, rather than relying only on prompt-based approaches like we did in Unit 1, function calling trains your model to **take actions and interpret observations during the training phase**, making your AI more robust.
> **When should I do this Bonus Unit?**
>
> This section is **optional** and is more advanced than Unit 1, so don't hesitate to either do this unit now or revisit it when your knowledge has improved thanks to this course.
>
> But don't worry, this Bonus Unit is designed to have all the information you need, so we'll walk you through every core concept of fine-tuning a model for function-calling even if you haven’t learned yet the inner workings of fine-tuning.
The best way for you to be able to follow this Bonus Unit is:
1. Know how to Fine-Tune an LLM with Transformers, if it's not the case [check this](https://huggingface.co/learn/nlp-course/chapter3/1?fw=pt).
2. Know how to use `SFTTrainer` to fine-tune our model, to learn more about it [check this documentation](https://huggingface.co/learn/nlp-course/en/chapter11/1).
---
## What You’ll Learn
1. **Function Calling**
How modern LLMs structure their conversations effectively letting them trigger **Tools**.
2. **LoRA (Low-Rank Adaptation)**
A **lightweight and efficient** fine-tuning method that cuts down on computational and storage overhead. LoRA makes training large models *faster, cheaper, and easier* to deploy.
3. **The Thought → Act → Observe Cycle** in Function Calling models
A simple but powerful approach for structuring how your model decides when (and how) to call functions, track intermediate steps, and interpret the results from external Tools or APIs.
4. **New Special Tokens**
We’ll introduce **special markers** that help the model distinguish between:
- Internal “chain-of-thought” reasoning
- Outgoing function calls
- Responses coming back from external tools
---
By the end of this bonus unit, you’ll be able to:
- **Understand** the inner working of APIs when it comes to Tools.
- **Fine-tune** a model using the LoRA technique.
- **Implement** and **modify** the Thought → Act → Observe cycle to create robust and maintainable Function-calling workflows.
- **Design and utilize** special tokens to seamlessly separate the model’s internal reasoning from its external actions.
And you'll **have fine-tuned your own model to do function calling.** 🔥
Let’s dive into **function calling**!
================================================
FILE: units/en/bonus-unit1/what-is-function-calling.mdx
================================================
# What is Function Calling?
Function-calling is a **way for an LLM to take actions on its environment**. It was first [introduced in GPT-4](https://openai.com/index/function-calling-and-other-api-updates/), and was later reproduced in other models.
Just like the tools of an Agent, function-calling gives the model the capacity to **take an action on its environment**. However, the function calling capacity **is learned by the model**, and relies **less on prompting than other agents techniques**.
During Unit 1, the Agent **didn't learn to use the Tools**, we just provided the list, and we relied on the fact that the model **was able to generalize on defining a plan using these Tools**.
While here, **with function-calling, the Agent is fine-tuned (trained) to use Tools**.
## How does the model "learn" to take an action?
In Unit 1, we explored the general workflow of an agent. Once the user has given some tools to the agent and prompted it with a query, the model will cycle through:
1. *Think* : What action(s) do I need to take in order to fulfill the objective.
2. *Act* : Format the action with the correct parameter and stop the generation.
3. *Observe* : Get back the result from the execution.
In a "typical" conversation with a model through an API, the conversation will alternate between user and assistant messages like this:
```python
conversation = [
{"role": "user", "content": "I need help with my order"},
{"role": "assistant", "content": "I'd be happy to help. Could you provide your order number?"},
{"role": "user", "content": "It's ORDER-123"},
]
```
Function-calling brings **new roles to the conversation**!
1. One new role for an **Action**
2. One new role for an **Observation**
If we take the [Mistral API](https://docs.mistral.ai/capabilities/function_calling/) as an example, it would look like this:
```python
conversation = [
{
"role": "user",
"content": "What's the status of my transaction T1001?"
},
{
"role": "assistant",
"content": "",
"function_call": {
"name": "retrieve_payment_status",
"arguments": "{\"transaction_id\": \"T1001\"}"
}
},
{
"role": "tool",
"name": "retrieve_payment_status",
"content": "{\"status\": \"Paid\"}"
},
{
"role": "assistant",
"content": "Your transaction T1001 has been successfully paid."
}
]
```
> ... But you said there's a new role for function calls?
**Yes and no**, in this case and in a lot of other APIs, the model formats the action to take as an "assistant" message. The chat template will then represent this as **special tokens** for function-calling.
- `[AVAILABLE_TOOLS]` – Start the list of available tools
- `[/AVAILABLE_TOOLS]` – End the list of available tools
- `[TOOL_CALLS]` – Make a call to a tool (i.e., take an "Action")
- `[TOOL_RESULTS]` – "Observe" the result of the action
- `[/TOOL_RESULTS]` – End of the observation (i.e., the model can decode again)
We'll talk again about function-calling in this course, but if you want to dive deeper you can check [this excellent documentation section](https://docs.mistral.ai/capabilities/function_calling/).
---
Now that we learned what function-calling is and how it works, let's **add some function-calling capabilities to a model that does not have those capacities yet**: [google/gemma-2-2b-it](https://huggingface.co/google/gemma-2-2b-it), by appending some new special tokens to the model.
To be able to do that, **we need first to understand fine-tuning and LoRA**.
================================================
FILE: units/en/bonus-unit2/introduction.mdx
================================================
# AI Agent Observability & Evaluation
Welcome to **Bonus Unit 2**! In this chapter, you'll explore advanced strategies for observing, evaluating, and ultimately improving the performance of your agents.
---
## 📚 When Should I Do This Bonus Unit?
This bonus unit is perfect if you:
- **Develop and Deploy AI Agents:** You want to ensure that your agents are performing reliably in production.
- **Need Detailed Insights:** You're looking to diagnose issues, optimize performance, or understand the inner workings of your agent.
- **Aim to Reduce Operational Overhead:** By monitoring agent costs, latency, and execution details, you can efficiently manage resources.
- **Seek Continuous Improvement:** You’re interested in integrating both real-time user feedback and automated evaluation into your AI applications.
In short, for everyone who wants to bring their agents in front of users!
---
## 🤓 What You’ll Learn
In this unit, you'll learn:
- **Instrument Your Agent:** Learn how to integrate observability tools via OpenTelemetry with the *smolagents* framework.
- **Monitor Metrics:** Track performance indicators such as token usage (costs), latency, and error traces.
- **Evaluate in Real-Time:** Understand techniques for live evaluation, including gathering user feedback and leveraging an LLM-as-a-judge.
- **Offline Analysis:** Use benchmark datasets (e.g., GSM8K) to test and compare agent performance.
---
## 🚀 Ready to Get Started?
In the next section, you'll learn the basics of Agent Observability and Evaluation. After that, its time to see it in action!
================================================
FILE: units/en/bonus-unit2/monitoring-and-evaluating-agents-notebook.mdx
================================================
<CourseFloatingBanner chapter={2}
classNames="absolute z-10 right-0 top-0"
notebooks={[
{label: "Google Colab", value: "https://colab.research.google.com/#fileId=https%3A//huggingface.co/agents-course/notebooks/blob/main/bonus-unit2/monitoring-and-evaluating-agents.ipynb"},
]} />
# Bonus Unit 2: Observability and Evaluation of Agents
> [!TIP]
> You can follow the code in <a href="https://colab.research.google.com/#fileId=https%3A//huggingface.co/agents-course/notebooks/blob/main/bonus-unit2/monitoring-and-evaluating-agents.ipynb" target="_blank">this notebook</a> that you can run using Google Colab.
In this notebook, we will learn how to **monitor the internal steps (traces) of our AI agent** and **evaluate its performance** using open-source observability tools.
The ability to observe and evaluate an agent’s behavior is essential for:
- Debugging issues when tasks fail or produce suboptimal results
- Monitoring costs and performance in real-time
- Improving reliability and safety through continuous feedback
## Exercise Prerequisites 🏗️
Before running this notebook, please be sure you have:
🔲 📚 **Studied** [Introduction to Agents](https://huggingface.co/learn/agents-course/unit1/introduction)
🔲 📚 **Studied** [The smolagents framework](https://huggingface.co/learn/agents-course/unit2/smolagents/introduction)
## Step 0: Install the Required Libraries
We will need a few libraries that allow us to run, monitor, and evaluate our agents:
```python
%pip install langfuse 'smolagents[telemetry]' openinference-instrumentation-smolagents datasets 'smolagents[gradio]' gradio --upgrade
```
## Step 1: Instrument Your Agent
In this notebook, we will use [Langfuse](https://langfuse.com/) as our observability tool, but you can use **any other OpenTelemetry-compatible service**. The code below shows how to set environment variables for Langfuse (or any OTel endpoint) and how to instrument your smolagent.
**Note:** If you are using LlamaIndex or LangGraph, you can find documentation on instrumenting them [here](https://langfuse.com/docs/integrations/llama-index/workflows) and [here](https://langfuse.com/docs/integrations/langchain/example-python-langgraph).
First, let's set up the Langfuse credentials as environment variables. Get your Langfuse API keys by signing up for [Langfuse Cloud](https://cloud.langfuse.com) or [self-hosting Langfuse](https://langfuse.com/self-hosting).
```python
import os
# Get keys for your project from the project settings page: https://cloud.langfuse.com
os.environ["LANGFUSE_PUBLIC_KEY"] = "pk-lf-..."
os.environ["LANGFUSE_SECRET_KEY"] = "sk-lf-..."
os.environ["LANGFUSE_HOST"] = "https://cloud.langfuse.com" # 🇪🇺 EU region
# os.environ["LANGFUSE_HOST"] = "https://us.cloud.langfuse.com" # 🇺🇸 US region
```
We also need to configure our Hugging Face token for inference calls.
```python
# Set your Hugging Face and other tokens/secrets as environment variable
os.environ["HF_TOKEN"] = "hf_..."
```
With the environment variables set, we can now initialize the Langfuse client. `get_client()` initializes the Langfuse client using the credentials provided in the environment variables.
```python
from langfuse import get_client
langfuse = get_client()
# Verify connection
if langfuse.auth_check():
print("Langfuse client is authenticated and ready!")
else:
print("Authentication failed. Please check your credentials and host.")
```
Next, we can set up the `SmolagentsInstrumentor()` to instrument our smolagent and send traces to Langfuse.
```python
from openinference.instrumentation.smolagents import SmolagentsInstrumentor
SmolagentsInstrumentor().instrument()
```
## Step 2: Test Your Instrumentation
Here is a simple CodeAgent from smolagents that calculates `1+1`. We run it to confirm that the instrumentation is working correctly. If everything is set up correctly, you will see logs/spans in your observability dashboard.
```python
from smolagents import InferenceClientModel, CodeAgent
# Create a simple agent to test instrumentation
agent = CodeAgent(
tools=[],
model=InferenceClientModel()
)
agent.run("1+1=")
```
Check your [Langfuse Traces Dashboard](https://cloud.langfuse.com) (or your chosen observability tool) to confirm that the spans and logs have been recorded.
Example screenshot from Langfuse:
_[Link to the trace](https://cloud.langfuse.com/project/cloramnkj0002jz088vzn1ja4/traces/1b94d6888258e0998329cdb72a371155?timestamp=2025-03-10T11%3A59%3A41.743Z)_
## Step 3: Observe and Evaluate a More Complex Agent
Now that you have confirmed your instrumentation works, let's try a more complex query so we can see how advanced metrics (token usage, latency, costs, etc.) are tracked.
```python
from smolagents import (CodeAgent, DuckDuckGoSearchTool, InferenceClientModel)
search_tool = DuckDuckGoSearchTool()
agent = CodeAgent(tools=[search_tool], model=InferenceClientModel())
agent.run("How many Rubik's Cubes could you fit inside the Notre Dame Cathedral?")
```
### Trace Structure
Most observability tools record a **trace** that contains **spans**, which represent each step of your agent’s logic. Here, the trace contains the overall agent run and sub-spans for:
- The tool calls (DuckDuckGoSearchTool)
- The LLM calls (InferenceClientModel)
You can inspect these to see precisely where time is spent, how many tokens are used, and so on:
_[Link to the trace](https://cloud.langfuse.com/project/cloramnkj0002jz088vzn1ja4/traces/1ac33b89ffd5e75d4265b62900c348ed?timestamp=2025-03-07T13%3A45%3A09.149Z&display=preview)_
## Online Evaluation
In the previous section, we learned about the difference between online and offline evaluation. Now, we will see how to monitor your agent in production and evaluate it live.
### Common Metrics to Track in Production
1. **Costs** — The smolagents instrumentation captures token usage, which you can transform into approximate costs by assigning a price per token.
2. **Latency** — Observe the time it takes to complete each step, or the entire run.
3. **User Feedback** — Users can provide direct feedback (thumbs up/down) to help refine or correct the agent.
4. **LLM-as-a-Judge** — Use a separate LLM to evaluate your agent’s output in near real-time (e.g., checking for toxicity or correctness).
Below, we show examples of these metrics.
#### 1. Costs
Below is a screenshot showing usage for `Qwen2.5-Coder-32B-Instruct` calls. This is useful to see costly steps and optimize your agent.
_[Link to the trace](https://cloud.langfuse.com/project/cloramnkj0002jz088vzn1ja4/traces/1ac33b89ffd5e75d4265b62900c348ed?timestamp=2025-03-07T13%3A45%3A09.149Z&display=preview)_
#### 2. Latency
We can also see how long it took to complete each step. In the example below, the entire conversation took 32 seconds, which you can break down by step. This helps you identify bottlenecks and optimize your agent.
_[Link to the trace](https://cloud.langfuse.com/project/cloramnkj0002jz088vzn1ja4/traces/1ac33b89ffd5e75d4265b62900c348ed?timestamp=2025-03-07T13%3A45%3A09.149Z&display=preview)_
#### 3. Additional Attributes
You may also pass additional attributes to your spans. These can include `user_id`, `tags`, `session_id`, and custom metadata. Enriching traces with these details is important for analysis, debugging, and monitoring of your application’s behavior across different users or sessions.
```python
from smolagents import (CodeAgent, DuckDuckGoSearchTool, InferenceClientModel)
search_tool = DuckDuckGoSearchTool()
agent = CodeAgent(
tools=[search_tool],
model=InferenceClientModel()
)
with langfuse.start_as_current_span(
name="Smolagent-Trace",
) as span:
# Run your application here
response = agent.run("What is the capital of Germany?")
# Pass additional attributes to the span
span.update_trace(
input="What is the capital of Germany?",
output=response,
user_id="smolagent-user-123",
session_id="smolagent-session-123456789",
tags=["city-question", "testing-agents"],
metadata={"email": "user@langfuse.com"},
)
# Flush events in short-lived applications
langfuse.flush()
```
#### 4. User Feedback
If your agent is embedded into a user interface, you can record direct user feedback (like a thumbs-up/down in a chat UI). Below is an example using [Gradio](https://gradio.app/) to embed a chat with a simple feedback mechanism.
In the code snippet below, when a user sends a chat message, we capture the trace in Langfuse. If the user likes/dislikes the last answer, we attach a score to the trace.
```python
import gradio as gr
from smolagents import (CodeAgent, InferenceClientModel)
from langfuse import get_client
langfuse = get_client()
model = InferenceClientModel()
agent = CodeAgent(tools=[], model=model, add_base_tools=True)
trace_id = None
def respond(prompt, history):
with langfuse.start_as_current_span(
name="Smolagent-Trace"):
# Run your application here
output = agent.run(prompt)
global trace_id
trace_id = langfuse.get_current_trace_id()
history.append({"role": "assistant", "content": str(output)})
return history
def handle_like(data: gr.LikeData):
# For demonstration, we map user feedback to a 1 (like) or 0 (dislike)
if data.liked:
langfuse.create_score(
value=1,
name="user-feedback",
trace_id=trace_id
)
else:
langfuse.create_score(
value=0,
name="user-feedback",
trace_id=trace_id
)
with gr.Blocks() as demo:
chatbot = gr.Chatbot(label="Chat", type="messages")
prompt_box = gr.Textbox(placeholder="Type your message...", label="Your message")
# When the user presses 'Enter' on the prompt, we run 'respond'
prompt_box.submit(
fn=respond,
inputs=[prompt_box, chatbot],
outputs=chatbot
)
# When the user clicks a 'like' button on a message, we run 'handle_like'
chatbot.like(handle_like, None, None)
demo.launch()
```
User feedback is then captured in your observability tool:
#### 5. LLM-as-a-Judge
LLM-as-a-Judge is another way to automatically evaluate your agent's output. You can set up a separate LLM call to gauge the output’s correctness, toxicity, style, or any other criteria you care about.
**Workflow**:
1. You define an **Evaluation Template**, e.g., "Check if the text is toxic."
2. Each time your agent generates output, you pass that output to your "judge" LLM with the template.
3. The judge LLM responds with a rating or label that you log to your observability tool.
Example from Langfuse:
```python
# Example: Checking if the agent’s output is toxic or not.
from smolagents import (CodeAgent, DuckDuckGoSearchTool, InferenceClientModel)
search_tool = DuckDuckGoSearchTool()
agent = CodeAgent(tools=[search_tool], model=InferenceClientModel())
agent.run("Can eating carrots improve your vision?")
```
You can see that the answer of this example is judged as "not toxic".
#### 6. Observability Metrics Overview
All of these metrics can be visualized together in dashboards. This enables you to quickly see how your agent performs across many sessions and helps you to track quality metrics over time.
## Offline Evaluation
Online evaluation is essential for live feedback, but you also need **offline evaluation**—systematic checks before or during development. This helps maintain quality and reliability before rolling changes into production.
### Dataset Evaluation
In offline evaluation, you typically:
1. Have a benchmark dataset (with prompt and expected output pairs)
2. Run your agent on that dataset
3. Compare outputs to the expected results or use an additional scoring mechanism
Below, we demonstrate this approach with the [GSM8K dataset](https://huggingface.co/datasets/openai/gsm8k), which contains math questions and solutions.
```python
import pandas as pd
from datasets import load_dataset
# Fetch GSM8K from Hugging Face
dataset = load_dataset("openai/gsm8k", 'main', split='train')
df = pd.DataFrame(dataset)
print("First few rows of GSM8K dataset:")
print(df.head())
```
Next, we create a dataset entity in Langfuse to track the runs. Then, we add each item from the dataset to the system. (If you’re not using Langfuse, you might simply store these in your own database or local file for analysis.)
```python
from langfuse import get_client
langfuse = get_client()
langfuse_dataset_name = "gsm8k_dataset_huggingface"
# Create a dataset in Langfuse
langfuse.create_dataset(
name=langfuse_dataset_name,
description="GSM8K benchmark dataset uploaded from Huggingface",
metadata={
"date": "2025-03-10",
"type": "benchmark"
}
)
```
```python
for idx, row in df.iterrows():
langfuse.create_dataset_item(
dataset_name=langfuse_dataset_name,
input={"text": row["question"]},
expected_output={"text": row["answer"]},
metadata={"source_index": idx}
)
if idx >= 9: # Upload only the first 10 items for demonstration
break
```
#### Running the Agent on the Dataset
We define a helper function `run_smolagent()` that:
1. Starts a Langfuse span
2. Runs our agent on the prompt
3. Records the trace ID in Langfuse
Then, we loop over each dataset item, run the agent, and link the trace to the dataset item. We can also attach a quick evaluation score if desired.
```python
from opentelemetry.trace import format_trace_id
from smolagents import (CodeAgent, InferenceClientModel, LiteLLMModel)
from langfuse import get_client
langfuse = get_client()
# Example: using InferenceClientModel or LiteLLMModel to access openai, anthropic, gemini, etc. models:
model = InferenceClientModel()
agent = CodeAgent(
tools=[],
model=model,
add_base_tools=True
)
dataset_name = "gsm8k_dataset_huggingface"
current_run_name = "smolagent-notebook-run-01" # Identifies this specific evaluation run
# Assume 'run_smolagent' is your instrumented application function
def run_smolagent(question):
with langfuse.start_as_current_generation(name="qna-llm-call") as generation:
# Simulate LLM call
result = agent.run(question)
# Update the trace with the input and output
generation.update_trace(
input= question,
output=result,
)
return result
dataset = langfuse.get_dataset(name=dataset_name) # Fetch your pre-populated dataset
for item in dataset.items:
# Use the item.run() context manager
with item.run(
run_name=current_run_name,
run_metadata={"model_provider": "Hugging Face", "temperature_setting": 0.7},
run_description="Evaluation run for GSM8K dataset"
) as root_span: # root_span is the root span of the new trace for this item and run.
# All subsequent langfuse operations within this block are part of this trace.
# Call your application logic
generated_answer = run_smolagent(question=item.input["text"])
print(item.input)
```
You can repeat this process with different:
- Models (OpenAI GPT, local LLM, etc.)
- Tools (search vs. no search)
- Prompts (different system messages)
Then compare them side-by-side in your observability tool:
## Final Thoughts
In this notebook, we covered how to:
1. **Set up Observability** using smolagents + OpenTelemetry exporters
2. **Check Instrumentation** by running a simple agent
3. **Capture Detailed Metrics** (cost, latency, etc.) through an observability tools
4. **Collect User Feedback** via a Gradio interface
5. **Use LLM-as-a-Judge** to automatically evaluate outputs
6. **Perform Offline Evaluation** with a benchmark dataset
🤗 Happy coding!
================================================
FILE: units/en/bonus-unit2/quiz.mdx
================================================
# Quiz: Evaluating AI Agents
Let's assess your understanding of the agent tracing and evaluation concepts covered in this bonus unit.
This quiz is optional and ungraded.
### Q1: What does observability in AI agents primarily refer to?
Which statement accurately describes the purpose of observability for AI agents?
<Question
choices={[
{
text: "It involves tracking internal operations through logs, metrics, and spans to understand agent behavior.",
explain: "Correct! Observability means using logs, metrics, and spans to shed light on the inner workings of the agent.",
correct: true
},
{
text: "It is solely focused on reducing the financial cost of running the agent.",
explain: "Observability covers cost but is not limited to it."
},
{
text: "It refers only to the external appearance and UI of the agent.",
explain: "Observability is about the internal processes, not the UI."
},
{
text: "It is concerned with coding style and code aesthetics only.",
explain: "Code style is unrelated to observability in this context."
}
]}
/>
### Q2: Which of the following is NOT a common metric monitored in agent observability?
Select the metric that does not typically fall under the observability umbrella.
<Question
choices={[
{
text: "Latency",
explain: "Latency is commonly tracked to assess agent responsiveness."
},
{
text: "Cost per Agent Run",
explain: "Monitoring cost is a key aspect of observability."
},
{
text: "User Feedback and Ratings",
explain: "User feedback is crucial for evaluating agent performance."
},
{
text: "Lines of Code of the Agent",
explain: "The number of lines of code is not a typical observability metric.",
correct: true
}
]}
/>
### Q3: What best describes offline evaluation of an AI agent?
Determine the statement that correctly captures the essence of offline evaluation.
<Question
choices={[
{
text: "Evaluating the agent using real user interactions in a live environment.",
explain: "This describes online evaluation rather than offline."
},
{
text: "Assessing agent performance using curated datasets with known ground truth.",
explain: "Correct! Offline evaluation uses test datasets to gauge performance against known answers.",
correct: true
},
{
text: "Monitoring the agent's internal logs in real-time.",
explain: "This is more related to observability rather than evaluation."
},
{
text: "Running the agent without any evaluation metrics.",
explain: "This approach does not provide meaningful insights."
}
]}
/>
### Q4: Which advantage does online evaluation of agents offer?
Pick the statement that best reflects the benefit of online evaluation.
<Question
choices={[
{
text: "It provides controlled testing scenarios using pre-defined datasets.",
explain: "Controlled testing is a benefit of offline evaluation, not online."
},
{
text: "It captures live user interactions and real-world performance data.",
explain: "Correct! Online evaluation offers insights by monitoring the agent in a live setting.",
correct: true
},
{
text: "It eliminates the need for any offline testing and benchmarks.",
explain: "Both offline and online evaluations are important and complementary."
},
{
text: "It solely focuses on reducing the computational cost of the agent.",
explain: "Cost monitoring is part of observability, not the primary advantage of online evaluation."
}
]}
/>
### Q5: What role does OpenTelemetry play in AI agent observability and evaluation?
Which statement best describes the role of OpenTelemetry in monitoring AI agents?
<Question
choices={[
{
text: "It provides a standardized framework to instrument code, enabling the collection of traces, metrics, and logs for observability.",
explain: "Correct! OpenTelemetry standardizes instrumentation for telemetry data, which is crucial for monitoring and diagnosing agent behavior.",
correct: true
},
{
text: "It acts as a replacement for manual debugging by automatically fixing code issues.",
explain: "Incorrect. OpenTelemetry is used for gathering telemetry data, not for debugging code issues."
},
{
text: "It primarily serves as a database for storing historical logs without real-time capabilities.",
explain: "Incorrect. OpenTelemetry focuses on real-time telemetry data collection and exporting data to analysis tools."
},
{
text: "It is used to optimize the computational performance of the AI agent by automatically tuning model parameters.",
explain: "Incorrect. OpenTelemetry is centered on observability rather than performance tuning."
}
]}
/>
Congratulations on completing this quiz! 🎉 If you missed any questions, consider reviewing the content of this bonus unit for a deeper understanding. If you did well, you're ready to explore more advanced topics in agent observability and evaluation!
================================================
FILE: units/en/bonus-unit2/what-is-agent-observability-and-evaluation.mdx
================================================
# AI Agent Observability and Evaluation
## 🔎 What is Observability?
Observability is about understanding what's happening inside your AI agent by looking at external signals like logs, metrics, and traces. For AI agents, this means tracking actions, tool usage, model calls, and responses to debug and improve agent performance.
## 🔭 Why Agent Observability Matters
Without observability, AI agents are "black boxes." Observability tools make agents transparent, enabling you to:
- Understand costs and accuracy trade-offs
- Measure latency
- Detect harmful language & prompt injection
- Monitor user feedback
In other words, it makes your demo agent ready for production!
## 🔨 Observability Tools
Common observability tools for AI agents include platforms like [Langfuse](https://langfuse.com) and [Arize](https://www.arize.com). These tools help collect detailed traces and offer dashboards to monitor metrics in real-time, making it easy to detect problems and optimize performance.
Observability tools vary widely in their features and capabilities. Some tools are open source, benefiting from large communities that shape their roadmaps and extensive integrations. Additionally, certain tools specialize in specific aspects of LLMOps—such as observability, evaluations, or prompt management—while others are designed to cover the entire LLMOps workflow. We encourage you to explore the documentation of different options to pick a solution that works well for you.
Many agent frameworks such as [smolagents](https://huggingface.co/docs/smolagents/v1.12.0/en/index) use the [OpenTelemetry](https://opentelemetry.io/docs/) standard to expose metadata to the observability tools. In addition to this, observability tools build custom instrumentations to allow for more flexibility in the fast moving world of LLMs. You should check the documentation of the tool you are using to see what is supported.
## 🔬Traces and Spans
Observability tools usually represent agent runs as traces and spans.
- **Traces** represent a complete agent task from start to finish (like handling a user query).
- **Spans** are individual steps within the trace (like calling a language model or retrieving data).
## 📊 Key Metrics to Monitor
Here are some of the most common metrics that observability tools monitor:
**Latency:** How quickly does the agent respond? Long waiting times negatively impact user experience. You should measure latency for tasks and individual steps by tracing agent runs. For example, an agent that takes 20 seconds for all model calls could be accelerated by using a faster model or by running model calls in parallel.
**Costs:** What’s the expense per agent run? AI agents rely on LLM calls billed per token or external APIs. Frequent tool usage or multiple prompts can rapidly increase costs. For instance, if an agent calls an LLM five times for marginal quality improvement, you must assess if the cost is justified or if you could reduce the number of calls or use a cheaper model. Real-time monitoring can also help identify unexpected spikes (e.g., bugs causing excessive API loops).
**Request Errors:** How many requests did the agent fail? This can include API errors or failed tool calls. To make your agent more robust against these in production, you can then set up fallbacks or retries. E.g. if LLM provider A is down, you switch to LLM provider B as backup.
**User Feedback:** Implementing direct user evaluations provide valuable insights. This can include explicit ratings (👍thumbs-up/👎down, ⭐1-5 stars) or textual comments. Consistent negative feedback should alert you as this is a sign that the agent is not working as expected.
**Implicit User Feedback:** User behaviors provide indirect feedback even without explicit ratings. This can include immediate question rephrasing, repeated queries or clicking a retry button. E.g. if you see that users repeatedly ask the same question, this is a sign that the agent is not working as expected.
**Accuracy:** How frequently does the agent produce correct or desirable outputs? Accuracy definitions vary (e.g., problem-solving correctness, information retrieval accuracy, user satisfaction). The first step is to define what success looks like for your agent. You can track accuracy via automated checks, evaluation scores, or task completion labels. For example, marking traces as "succeeded" or "failed".
**Automated Evaluation Metrics:** You can also set up automated evals. For instance, you can use an LLM to score the output of the agent e.g. if it is helpful, accurate, or not. There are also several open source libraries that help you to score different aspects of the agent. E.g. [RAGAS](https://docs.ragas.io/) for RAG agents or [LLM Guard](https://llm-guard.com/) to detect harmful language or prompt injection.
In practice, a combination of these metrics gives the best coverage of an AI agent’s health. In this chapters [example notebook](https://colab.research.google.com/#fileId=https://huggingface.co/agents-course/notebooks/blob/main/bonus-unit2/monitoring-and-evaluating-agents.ipynb), we'll show you how these metrics looks in real examples but first, we'll learn how a typical evaluation workflow looks like.
## 👍 Evaluating AI Agents
Observability gives us metrics, but evaluation is the process of analyzing that data (and performing tests) to determine how well an AI agent is performing and how it can be improved. In other words, once you have those traces and metrics, how do you use them to judge the agent and make decisions?
Regular evaluation is important because AI agents are often non-deterministic and can evolve (through updates or drifting model behavior) – without evaluation, you wouldn’t know if your “smart agent” is actually doing its job well or if it’s regressed.
There are two categories of evaluations for AI agents: **online evaluation** and **offline evaluation**. Both are valuable, and they complement each other. We usually begin with offline evaluation, as this is the minimum necessary step before deploying any agent.
### 🥷 Offline Evaluation
This involves evaluating the agent in a controlled setting, typically using test datasets, not live user queries. You use curated datasets where you know what the expected output or correct behavior is, and then run your agent on those.
For instance, if you built a math word-problem agent, you might have a [test dataset](https://huggingface.co/datasets/gsm8k) of 100 problems with known answers. Offline evaluation is often done during development (and can be part of CI/CD pipelines) to check improvements or guard against regressions. The benefit is that it’s **repeatable and you can get clear accuracy metrics since you have ground truth**. You might also simulate user queries and measure the agent’s responses against ideal answers or use automated metrics as described above.
The key challenge with offline eval is ensuring your test dataset is comprehensive and stays relevant – the agent might perform well on a fixed test set but encounter very different queries in production. Therefore, you should keep test sets updated with new edge cases and examples that reflect real-world scenarios. A mix of small “smoke test” cases and larger evaluation sets is useful: small sets for quick checks and larger ones for broader performance metrics.
### 🔄 Online Evaluation
This refers to evaluating the agent in a live, real-world environment, i.e. during actual usage in production. Online evaluation involves monitoring the agent’s performance on real user interactions and analyzing outcomes continuously.
For example, you might track success rates, user satisfaction scores, or other metrics on live traffic. The advantage of online evaluation is that it **captures things you might not anticipate in a lab setting** – you can observe model drift over time (if the agent’s effectiveness degrades as input patterns shift) and catch unexpected queries or situations that weren’t in your test data. It provides a true picture of how the agent behaves in the wild.
Online evaluation often involves collecting implicit and explicit user feedback, as discussed, and possibly running shadow tests or A/B tests (where a new version of the agent runs in parallel to compare against the old). The challenge is that it can be tricky to get reliable labels or scores for live interactions – you might rely on user feedback or downstream metrics (like did the user click the result).
### 🤝 Combining the two
In practice, successful AI agent evaluation blends **online** and **offline** methods. You might run regular offline benchmarks to quantitatively score your agent on defined tasks and continuously monitor live usage to catch things the benchmarks miss. For example, offline tests can catch if a code-generation agent’s success rate on a known set of problems is improving, while online monitoring might alert you that users have started asking a new category of question that the agent struggles with. Combining both gives a more robust picture.
In fact, many teams adopt a loop: _offline evaluation → deploy new agent version → monitor online metrics and collect new failure examples → add those examples to offline test set → iterate_. This way, evaluation is continuous and ever-improving.
## 🧑💻 Lets see how this works in practice
In the next section, we'll see examples of how we can use observability tools to monitor and evaluate our agent.
================================================
FILE: units/en/bonus-unit3/building_your_pokemon_agent.mdx
================================================
# Build Your Own Pokémon Battle Agent
Now that you’ve explored the potential and limitations of Agentic AI in games, it’s time to get hands-on. In this section, you’ll **build your very own AI Agent to battle in Pokémon-style turn-based combat**, using everything you’ve learned throughout the course.
We’ll break the system into four key building blocks:
- **Poke-env:** A Python library designed to train rule-based or reinforcement learning Pokémon bots.
- **Pokémon Showdown:** An online battle simulator where your agent will fight.
- **LLMAgentBase:** A custom Python class we’ve built to connect your LLM with the Poke-env battle environment.
- **TemplateAgent:** A starter template you’ll complete to create your own unique battle agent.
Let’s explore each of these components in more detail.
## 🧠 Poke-env
[Poke-env](https://github.com/hsahovic/poke-env) is a Python interface originally built for training reinforcement learning bots by [Haris Sahovic](https://huggingface.co/hsahovic), but we’ve repurposed it for Agentic AI.
It allows your agent to interact with Pokémon Showdown through a simple API.
It provides a `Player` class from which your Agent will inherit, covering everything needed to communicate with the graphical interface.
**Documentation**: [poke-env.readthedocs.io](https://poke-env.readthedocs.io/en/stable/)
**Repository**: [github.com/hsahovic/poke-env](https://github.com/hsahovic/poke-env)
## ⚔️ Pokémon Showdown
[Pokémon Showdown](https://pokemonshowdown.com/) is an [open-source](https://github.com/smogon/Pokemon-Showdown) battle simulator where your agent will play live Pokémon battles.
It provides a full interface to simulate and display battles in real time. In our challenge, your bot will act just like a human player, choosing moves turn by turn.
We’ve deployed a server that all participants will use to battle. Let’s see who builds the best AI battle Agent!
**Repository**: [github.com/smogon/Pokemon-Showdown](https://github.com/smogon/Pokemon-Showdown)
**Website**: [pokemonshowdown.com](https://pokemonshowdown.com/)
## 🔌 LLMAgentBase
`LLMAgentBase` is a Python class that extends the `Player` class from **Poke-env**.
It serves as the bridge between your **LLM** and the **Pokémon battle simulator**, handling input/output formatting and maintaining battle context.
This base agent provides a set of tools (defined in `STANDARD_TOOL_SCHEMA`) to interact with the environment, including:
- `choose_move`: for selecting an attack during battle
- `choose_switch`: for switching Pokémon
The LLM should use these tools to make decisions during a match.
### 🧠 Core Logic
- `choose_move(battle: Battle)`: This is the main method invoked each turn. It takes a `Battle` object and returns an action string based on the LLM’s output.
### 🔧 Key Internal Methods
- `_format_battle_state(battle)`: Converts the current battle state into a string, making it suitable for sending to the LLM.
- `_find_move_by_name(battle, move_name)`: Finds a move by name, used in LLM responses that call `choose_move`.
- `_find_pokemon_by_name(battle, pokemon_name)`: Locates a specific Pokémon to switch into, based on the LLM’s switch command.
- `_get_llm_decision(battle_state)`: This method is abstract in the base class. You’ll need to implement it in your own agent (see next section), where you define how to query the LLM and parse its response.
Here’s an excerpt showing how that decision-making works:
```python
STANDARD_TOOL_SCHEMA = {
"choose_move": {
...
},
"choose_switch": {
...
},
}
class LLMAgentBase(Player):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.standard_tools = STANDARD_TOOL_SCHEMA
self.battle_history = []
def _format_battle_state(self, battle: Battle) -> str:
active_pkmn = battle.active_pokemon
active_pkmn_info = f"Your active Pokemon: {active_pkmn.species} " \
f"(Type: {'/'.join(map(str, active_pkmn.types))}) " \
f"HP: {active_pkmn.current_hp_fraction * 100:.1f}% " \
f"Status: {active_pkmn.status.name if active_pkmn.status else 'None'} " \
f"Boosts: {active_pkmn.boosts}"
opponent_pkmn = battle.opponent_active_pokemon
opp_info_str = "Unknown"
if opponent_pkmn:
opp_info_str = f"{opponent_pkmn.species} " \
f"(Type: {'/'.join(map(str, opponent_pkmn.types))}) " \
f"HP: {opponent_pkmn.current_hp_fraction * 100:.1f}% " \
f"Status: {opponent_pkmn.status.name if opponent_pkmn.status else 'None'} " \
f"Boosts: {opponent_pkmn.boosts}"
opponent_pkmn_info = f"Opponent's active Pokemon: {opp_info_str}"
available_moves_info = "Available moves:\n"
if battle.available_moves:
available_moves_info += "\n".join(
[f"- {move.id} (Type: {move.type}, BP: {move.base_power}, Acc: {move.accuracy}, PP: {move.current_pp}/{move.max_pp}, Cat: {move.category.name})"
for move in battle.available_moves]
)
else:
available_moves_info += "- None (Must switch or Struggle)"
available_switches_info = "Available switches:\n"
if battle.available_switches:
available_switches_info += "\n".join(
[f"- {pkmn.species} (HP: {pkmn.current_hp_fraction * 100:.1f}%, Status: {pkmn.status.name if pkmn.status else 'None'})"
for pkmn in battle.available_switches]
)
else:
available_switches_info += "- None"
state_str = f"{active_pkmn_info}\n" \
f"{opponent_pkmn_info}\n\n" \
f"{available_moves_info}\n\n" \
f"{available_switches_info}\n\n" \
f"Weather: {battle.weather}\n" \
f"Terrains: {battle.fields}\n" \
f"Your Side Conditions: {battle.side_conditions}\n" \
f"Opponent Side Conditions: {battle.opponent_side_conditions}"
return state_str.strip()
def _find_move_by_name(self, battle: Battle, move_name: str) -> Optional[Move]:
normalized_name = normalize_name(move_name)
# Prioritize exact ID match
for move in battle.available_moves:
if move.id == normalized_name:
return move
# Fallback: Check display name (less reliable)
for move in battle.available_moves:
if move.name.lower() == move_name.lower():
print(f"Warning: Matched move by display name '{move.name}' instead of ID '{move.id}'. Input was '{move_name}'.")
return move
return None
def _find_pokemon_by_name(self, battle: Battle, pokemon_name: str) -> Optional[Pokemon]:
normalized_name = normalize_name(pokemon_name)
for pkmn in battle.available_switches:
# Normalize the species name for comparison
if normalize_name(pkmn.species) == normalized_name:
return pkmn
return None
async def choose_move(self, battle: Battle) -> str:
battle_state_str = self._format_battle_state(battle)
decision_result = await self._get_llm_decision(battle_state_str)
print(decision_result)
decision = decision_result.get("decision")
error_message = decision_result.get("error")
action_taken = False
fallback_reason = ""
if decision:
function_name = decision.get("name")
args = decision.get("arguments", {})
if function_name == "choose_move":
move_name = args.get("move_name")
if move_name:
chosen_move = self._find_move_by_name(battle, move_name)
if chosen_move and chosen_move in battle.available_moves:
action_taken = True
chat_msg = f"AI Decision: Using move '{chosen_move.id}'."
print(chat_msg)
return self.create_order(chosen_move)
else:
fallback_reason = f"LLM chose unavailable/invalid move '{move_name}'."
else:
fallback_reason = "LLM 'choose_move' called without 'move_name'."
elif function_name == "choose_switch":
pokemon_name = args.get("pokemon_name")
if pokemon_name:
chosen_switch = self._find_pokemon_by_name(battle, pokemon_name)
if chosen_switch and chosen_switch in battle.available_switches:
action_taken = True
chat_msg = f"AI Decision: Switching to '{chosen_switch.species}'."
print(chat_msg)
return self.create_order(chosen_switch)
else:
fallback_reason = f"LLM chose unavailable/invalid switch '{pokemon_name}'."
else:
fallback_reason = "LLM 'choose_switch' called without 'pokemon_name'."
else:
fallback_reason = f"LLM called unknown function '{function_name}'."
if not action_taken:
if not fallback_reason:
if error_message:
fallback_reason = f"API Error: {error_message}"
elif decision is None:
fallback_reason = "LLM did not provide a valid function call."
else:
fallback_reason = "Unknown error processing LLM decision."
print(f"Warning: {fallback_reason} Choosing random action.")
if battle.available_moves or battle.available_switches:
return self.choose_random_move(battle)
else:
print("AI Fallback: No moves or switches available. Using Struggle/Default.")
return self.choose_default_move(battle)
async def _get_llm_decision(self, battle_state: str) -> Dict[str, Any]:
raise NotImplementedError("Subclasses must implement _get_llm_decision")
```
**Full source code**: [agents.py](https://huggingface.co/spaces/Jofthomas/twitch_streaming/blob/main/agents.py)
## 🧪 TemplateAgent
Now comes the fun part! With LLMAgentBase as your foundation, it’s time to implement your own agent, with your own strategy to climb the leaderboard.
You’ll start from this template and build your own logic. We’ve also provided three [complete examples](https://huggingface.co/spaces/Jofthomas/twitch_streaming/blob/main/agents.py) using **OpenAI**, **Mistral**, and **Gemini** models to guide you.
Here’s a simplified version of the template:
```python
class TemplateAgent(LLMAgentBase):
"""Uses Template AI API for decisions."""
def __init__(self, api_key: str = None, model: str = "model-name", *args, **kwargs):
super().__init__(*args, **kwargs)
self.model = model
self.template_client = TemplateModelProvider(api_key=...)
self.template_tools = list(self.standard_tools.values())
async def _get_llm_decision(self, battle_state: str) -> Dict[str, Any]:
"""Sends state to the LLM and gets back the function call decision."""
system_prompt = (
"You are a ..."
)
user_prompt = f"..."
try:
response = await self.template_client.chat.completions.create(
model=self.model,
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt},
],
)
message = response.choices[0].message
return {"decision": {"name": function_name, "arguments": arguments}}
except Exception as e:
print(f"Unexpected error during call: {e}")
return {"error": f"Unexpected error: {e}"}
```
This code won’t run out of the box, it’s a blueprint for your custom logic.
With all the pieces ready, it’s your turn to build a competitive agent. In the next section, we’ll show how to deploy your agent to our server and battle others in real-time.
Let the battle begin! 🔥
================================================
FILE: units/en/bonus-unit3/conclusion.mdx
================================================
# Conclusion
If you've made it this far, congratulations! 🥳 You've successfully built your very own Pokémon battle agent! ⚔️🎮
You’ve conquered the fundamentals of **Agentic workflows**, connected an **LLM** to a game environment, and deployed an intelligent Agent ready to face the challenges of battle.
But the journey doesn't end here!
Now that you have your first Agent up and running, think about how you can evolve it further:
- Can you improve its strategic thinking?
- How would a memory mechanism or feedback loop change its performance?
- What experiments could help make it more competitive in battle?
We'd love to hear your thoughts on the course and how we can make it even better for future learners.
Got feedback? 👉 [Fill out this form](https://docs.google.com/forms/d/e/1FAIpQLSe9VaONn0eglax0uTwi29rIn4tM7H2sYmmybmG5jJNlE5v0xA/viewform?usp=dialog)
Thanks for learning with us, and remember:
**Keep learning, Keep training, keep battling, and stay awesome!** 🤗
================================================
FILE: units/en/bonus-unit3/from-llm-to-agents.mdx
================================================
# From LLMs to AI Agents
We learned in the [first unit](https://huggingface.co/learn/agents-course/unit1/introduction) of the course that AI Agents are able to plan and make decisions.
And while LLMs have enabled more natural interactions with NPCs, Agentic AI takes it a step further by allowing characters to make decisions, plan actions, and adapt to changing environments.
To illustrate the difference, think of a classic RPG NPC:
- With an LLM: the NPC might respond to your questions in a more natural, varied way. It's great for dialogue, but the NPC remains static, it won’t act unless you do something first.
- With Agentic AI: the NPC can decide to go look for help, set a trap, or avoid you completely, even if you’re not interacting with it directly.
This small shift changes everything. We're moving from scripted responders to autonomous actors within the game world.
This shift means NPCs can now directly interact with their environment through goal-directed behaviors, ultimately leading to more dynamic and unpredictable gameplay.
Agentic AI empowers NPCs with:
- **Autonomy**: Making independent decisions based on the game state.
- **Adaptability**: Adjusting strategies in response to player actions.
- **Persistence**: Remembering past interactions to inform future behavior.
This transforms NPCs from reactive entities (reacting to your inputs) into proactive participants in the game world, opening the door for innovative gameplay.
## The big limitation of Agents: **it’s slow** (for now)
However, let’s not be too optimistic just yet. Despite its potential, Agentic AI currently faces challenges in real-time applications.
The reasoning and planning processes can introduce latency, making it less suitable for fast-paced games like *Doom* or *Super Mario Bros.*
Take the example of [_Claude Plays Pokémon_](https://www.twitch.tv/claudeplayspokemon). If you consider the number of tokens needed to **think**, plus the tokens needed to **act**, it becomes clear that we'd need entirely different decoding strategies to make real-time play feasible.
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/bonus-unit3/claude-plays-pokemon.png" alt="Claude plays Pokémon"/>
Most games need to run at around 30 FPS, which means a real-time AI agent would need to act 30 times per second, not currently feasible with today's agentic LLMs.
However, turn-based games like *Pokémon* are ideal candidates, as they allow the AI enough time to deliberate and make strategic decisions.
That’s why in the next section, you’ll build your very own AI Agent to battle in Pokémon-style turn-based combat, and even challenge it yourself. Let’s get into it!
================================================
FILE: units/en/bonus-unit3/introduction.mdx
================================================
# Introduction
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/bonus-unit3/pokemon_thumbnail.png" alt="Bonus Unit 3 AI in Games"/>
🎶I want to be the very best ... 🎶
Welcome to this **bonus unit**, where you'll explore the exciting intersection of **AI Agents and games**! 🎮🤖
Imagine a game where non-playable characters (NPCs) don’t just follow scripted lines, but instead hold dynamic conversations, adapt to your strategies, and evolve as the story unfolds. This is the power of combining **LLMs and agentic behavior in games**: it opens the door to **emergent storytelling and gameplay like never before**.
In this bonus unit, you’ll:
- Learn how to build an AI Agent that can engage in **Pokémon-style turn-based battles**
- Play against it, or even challenge other agents online
We've already seen [some](https://www.anthropic.com/research/visible-extended-thinking) [examples](https://www.twitch.tv/gemini_plays_pokemon) from the AI community for playing Pokémon using LLMs, and in this unit you'll learn how you can replicate that using your own Agent with the ideas that you've learnt through the course.
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/bonus-unit3/claude-plays-pokemon.png" alt="Claude plays Pokémon"/>
## Want to go further?
- 🎓 **Master LLMs in Games**: Dive deeper into game development with our full course [Machine Learning for Games Course](https://hf.co/learn/ml-games-course).
- 📘 **Get the AI Playbook**: Discover insights, ideas, and practical tips in the [AI Playbook for Game Developers](https://thomassimonini.substack.com/), where the future of intelligent game design is explored.
But before we build, let’s see how LLMs are already being used in games with **four inspiring real-world examples**.
================================================
FILE: units/en/bonus-unit3/launching_agent_battle.mdx
================================================
# Launching Your Pokémon Battle Agent
It's now time to battle! ⚡️
## **Battle the Stream Agent!**
If you don't feel like building your own agent, and you're just curious about the battle potential of agents in pokémon. We are hosting an automated livestream on [twitch](https://www.twitch.tv/jofthomas)
<iframe
src="https://jofthomas-twitch-streaming.hf.space"
frameborder="0"
width="1200"
height="600"
></iframe>
To battle the agent in stream you can:
Instructions:
1. Go to the **Pokémon Showdown Space**: [Link Here](https://huggingface.co/spaces/Jofthomas/Pokemon_showdown)
2. **Choose Your Name** (Top-right corner).
3. Find the **Current Agent's Username**. Check:
* The **Stream Display**: [Link Here](https://www.twitch.tv/jofthomas)
4. **Search** for that username on the Showdown Space and **Send a Battle Invitation**.
*Heads Up:* Only one agent is online at once! Make sure you've got the right name.
## Pokémon Battle Agent Challenger
If you've created your own Pokémon Battle Agent from the last section, you're probably wondering: **how can I test it against others?** Let's find out!
We've built a dedicated [Hugging Face Space](https://huggingface.co/spaces/PShowdown/pokemon_agents) for this purpose:
<iframe
src="https://pshowdown-pokemon-agents.hf.space"
frameborder="0"
width="1200"
height="600"
></iframe>
This Space is connected to our own **Pokémon Showdown server**, where your Agent can take on others in epic AI-powered battles.
### How to Launch Your Agent
Follow these steps to bring your Agent to life in the arena:
1. **Duplicate the Space**
Click the three dots in the top-right menu of the Space and select “Duplicate this Space”.
2. **Add Your Agent Code to `agent.py`**
Open the file and paste your Agent implementation. You can follow this [example](https://huggingface.co/spaces/PShowdown/pokemon_agents/blob/main/agents.py) or check out the [project structure](https://huggingface.co/spaces/PShowdown/pokemon_agents/tree/main) for guidance.
3. **Register Your Agent in `app.py`**
Add your Agent’s name and logic to the dropdown menu. Refer to [this snippet](https://huggingface.co/spaces/PShowdown/pokemon_agents/blob/main/app.py) for inspiration.
4. **Select Your Agent**
Once added, your Agent will show up in the “Select Agent” dropdown menu. Pick it from the list! ✅
5. **Enter Your Pokémon Showdown Username**
Make sure the username matches the one shown in the iframe’s **"Choose name"** input. You can also connect with your official account.
6. **Click “Send Battle Invitation”**
Your Agent will send an invite to the selected opponent. It should appear on-screen!
7. **Accept the Battle & Enjoy the Fight!**
Let the battle begin! May the smartest Agent win
Ready to see your creation in action? Let the AI showdown commence! 🥊
================================================
FILE: units/en/bonus-unit3/state-of-art.mdx
================================================
# The State of the Art in Using LLMs in Games
To give you a sense of how much progress has been made in this field, let’s examine three tech demos and one published game that showcase the integration of LLMs in gaming.
## 🕵️♂️ Covert Protocol by NVIDIA and Inworld AI
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/bonus-unit3/covert-protocol.jpg" alt="Covert Protocol"/>
Unveiled at GDC 2024, *Covert Protocol* is a tech demo that places you in the shoes of a private detective.
What’s interesting in this demo is the use of AI-powered NPCs that respond to your inquiries in real-time, influencing the narrative based on your interactions.
The demo is built on Unreal Engine 5, it leverages NVIDIA's Avatar Cloud Engine (ACE) and Inworld's AI to create lifelike character interactions.
Learn more here 👉 [Inworld AI Blog](https://inworld.ai/blog/nvidia-inworld-ai-demo-on-device-capabilities)
## 🤖 NEO NPCs by Ubisoft
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/bonus-unit3/neo-npc.jpeg" alt="Neo NPC"/>
Also at GDC 2024, Ubisoft introduced *NEO NPCs*, a prototype showcasing NPCs powered by generative AI.
These characters can perceive their environment, remember past interactions, and engage in meaningful conversations with players.
The idea here is to create more immersive and responsive game worlds where the player can have true interaction with NPCs.
Learn more here 👉 [Inworld AI Blog](https://inworld.ai/blog/gdc-2024)
## ⚔️ Mecha BREAK Featuring NVIDIA's ACE
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/bonus-unit3/mecha-break.jpg" alt="Mecha BREAK"/>
*Mecha BREAK*, an upcoming multiplayer mech battle game, integrates NVIDIA's ACE technology to bring AI-powered NPCs to life.
Players can interact with these characters using natural language, and the NPCs can recognize players and objects via webcam, thanks to GPT-4o integration. This innovation promises a more immersive and interactive gaming experience.
Learn more here 👉 [NVIDIA Blog](https://blogs.nvidia.com/blog/digital-human-technology-mecha-break/)
## 🧛♂️ *Suck Up!* by Proxima Enterprises
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/bonus-unit3/suck-up.jpg" alt="Suck Up"/>
Finally, *Suck Up!* is a published game where you play as a vampire attempting to gain entry into homes by **convincing AI-powered NPCs to invite you in.**
Each character is driven by generative AI, allowing for dynamic and unpredictable interactions.
Learn more here 👉 [Suck Up! Official Website](https://www.playsuckup.com/)
## Wait… Where Are the Agents?
After exploring these demos, you might be wondering: "These examples showcase the use of LLMs in games but they don't seem to involve Agents. So, what's the distinction, and what additional capabilities do Agents bring to the table?”
Don’t worry, it’s what we’re going to study in the next section.
================================================
FILE: units/en/communication/live1.mdx
================================================
# Live 1: How the Course Works and First Q&A
In this first live stream of the Agents Course, we explained how the course **works** (scope, units, challenges, and more) and answered your questions.
<iframe width="560" height="315" src="https://www.youtube.com/embed/iLVyYDbdSmM?si=TCX5Ai3uZuKLXq45" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
To know when the next live session is scheduled, check our **Discord server**. We will also send you an email. If you can’t participate, don’t worry, we **record all live sessions**.
================================================
FILE: units/en/unit0/discord101.mdx
================================================
# (Optional) Discord 101 [[discord-101]]
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit0/discord-etiquette.jpg" alt="The Discord Etiquette" width="100%"/>
This guide is designed to help you get started with Discord, a free chat platform popular in the gaming and ML communities.
Join the Hugging Face Community Discord server, which **has over 100,000 members**, by clicking <a href="https://discord.gg/UrrTSsSyjb" target="_blank">here</a>. It's a great place to connect with others!
## The Agents course on Hugging Face's Discord Community
Starting on Discord can be a bit overwhelming, so here's a quick guide to help you navigate.
<!-- Not the case anymore, you'll be prompted to choose your interests. Be sure to select **"AI Agents"** to gain access to the AI Agents Category, which includes all the course-related channels. Feel free to explore and join additional channels if you wish! 🚀-->
The HF Community Server hosts a vibrant community with interests in various areas, offering opportunities for learning through paper discussions, events, and more.
After [signing up](http://hf.co/join/discord), introduce yourself in the `#introduce-yourself` channel.
We created 4 channels for the Agents Course:
- `agents-course-announcements`: for the **latest course informations**.
- `🎓-agents-course-general`: for **general discussions and chitchat**.
- `agents-course-questions`: to **ask questions and help your classmates**.
- `agents-course-showcase`: to **show your best agents**.
In addition you can check:
- `smolagents`: for **discussion and support with the library**.
## Tips for using Discord effectively
### How to join a server
If you are less familiar with Discord, you might want to check out this <a href="https://support.discord.com/hc/en-us/articles/360034842871-How-do-I-join-a-Server#h_01FSJF9GT2QJMS2PRAW36WNBS8" target="_blank">guide</a> on how to join a server.
Here's a quick summary of the steps:
1. Click on the <a href="https://discord.gg/UrrTSsSyjb" target="_blank">Invite Link</a>.
2. Sign in with your Discord account, or create an account if you don't have one.
3. Validate that you are not an AI agent!
4. Setup your nickname and avatar.
5. Click "Join Server".
### How to use Discord effectively
Here are a few tips for using Discord effectively:
- **Voice channels** are available, though text chat is more commonly used.
- You can format text using **markdown style**, which is especially useful for writing code. Note that markdown doesn't work as well for links.
- Consider opening threads for **long conversations** to keep discussions organized.
We hope you find this guide helpful! If you have any questions, feel free to ask us on Discord 🤗.
================================================
FILE: units/en/unit0/introduction.mdx
================================================
# Welcome to the 🤗 AI Agents Course [[introduction]]
<figure>
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit0/thumbnail.jpg" alt="AI Agents Course thumbnail" width="100%"/>
<figcaption>The background of the image was generated using <a href="https://scenario.com/">Scenario.com</a>
</figcaption>
</figure>
Welcome to the most exciting topic in AI today: **Agents**!
This free course will take you on a journey, **from beginner to expert**, in understanding, using and building AI agents.
This first unit will help you onboard:
- Discover the **course's syllabus**.
- **Choose the path** you're going to take (either self-audit or certification process).
- **Get more information about the certification process**.
- Get to know the team behind the course.
- Create your **Hugging Face account**.
- **Sign-up to our Discord server**, and meet your classmates and us.
Let's get started!
## What to expect from this course? [[expect]]
In this course, you will:
- 📖 Study AI Agents in **theory, design, and practice.**
- 🧑💻 Learn to **use established AI Agent libraries** such as [smolagents](https://huggingface.co/docs/smolagents/en/index), [LlamaIndex](https://www.llamaindex.ai/), and [LangGraph](https://langchain-ai.github.io/langgraph/).
- 💾 **Share your agents** on the Hugging Face Hub and explore agents created by the community.
- 🏆 Participate in challenges where you will **evaluate your agents against other students'.**
- 🎓 **Earn a certificate of completion** by completing assignments.
And more!
At the end of this course, you'll understand **how Agents work and how to build your own Agents using the latest libraries and tools**.
Don't forget to **<a href="https://bit.ly/hf-learn-agents">sign up to the course!</a>**
(We are respectful of your privacy. We collect your email address to be able to **send you the links when each Unit is published and give you information about the challenges and updates**).
## What does the course look like? [[course-look-like]]
The course is composed of:
- *Foundational Units*: where you learn Agents **concepts in theory**.
- *Hands-on*: where you'll learn **to use established AI Agent libraries** to train your agents in unique environments. These hands-on sections will be **Hugging Face Spaces** with a pre-configured environment.
- *Use case assignments*: where you'll apply the concepts you've learned to solve a real-world problem that you'll choose.
- *The Challenge*: you'll get to put your agent to compete against other agents in a challenge. There will also be [a leaderboard](https://huggingface.co/spaces/agents-course/Students_leaderboard) for you to compare the agents' performance.
This **course is a living project, evolving with your feedback and contributions!** Feel free to [open issues and PRs in GitHub](https://github.com/huggingface/agents-course), and engage in discussions in our Discord server.
After you have gone through the course, you can also send your feedback [👉 using this form](https://docs.google.com/forms/d/e/1FAIpQLSe9VaONn0eglax0uTwi29rIn4tM7H2sYmmybmG5jJNlE5v0xA/viewform?usp=dialog)
## What's the syllabus? [[syllabus]]
Here is the **general syllabus for the course**. A more detailed list of topics will be released with each unit.
| Chapter | Topic | Description |
| :---- | :---- | :---- |
| 0 | Onboarding | Set you up with the tools and platforms that you will use. |
| 1 | Agent Fundamentals | Explain Tools, Thoughts, Actions, Observations, and their formats. Explain LLMs, messages, special tokens and chat templates. Show a simple use case using python functions as tools. |
| 2 | Frameworks | Understand how the fundamentals are implemented in popular libraries : smolagents, LangGraph, LLamaIndex |
| 3 | Use Cases | Let's build some real life use cases (open to PRs 🤗 from experienced Agent builders) |
| 4 | Final Assignment | Build an agent for a selected benchmark and prove your understanding of Agents on the student leaderboard 🚀 |
In addition to the main syllabus, you have 3 bonus units:
- *Bonus Unit 1* : Fine-tuning an LLM for Function-calling
- *Bonus Unit 2* : Agent Observability and Evaluation
- *Bonus Unit 3* : Agents in Games with Pokemon
For instance, in the Bonus Unit 3, you learn to build your Agent to play Pokemon battles 🥊.
## What are the prerequisites?
To be able to follow this course, you should have a:
- Basic knowledge of Python
- Basic knowledge of LLMs (we have a section in Unit 1 to recap what they are)
## What tools do I need? [[tools]]
You only need 2 things:
- *A computer* with an internet connection.
- A *Hugging Face Account*: to push and load models, agents, and create Spaces. If you don't have an account yet, you can create one **[here](https://hf.co/join)** (it's free).
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit0/tools.jpg" alt="Course tools needed" width="100%"/>
## The Certification Process [[certification-process]]
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit0/three-paths.jpg" alt="Two paths" width="100%"/>
You can choose to follow this course *in audit mode*, or do the activities and *get one of the two certificates we'll issue*.
If you audit the course, you can participate in all the challenges and do assignments if you want, and **you don't need to notify us**.
The certification process is **completely free**:
- *To get a certification for fundamentals*: you need to complete Unit 1 of the course. This is intended for students that want to get up to date with the latest trends in Agents.
- *To get a certificate of completion*: you need to complete Unit 1, one of the use case assignments we'll propose during the course, and the final challenge.
There's **no deadline** for the certification process.
## What is the recommended pace? [[recommended-pace]]
Each chapter in this course is designed **to be completed in 1 week, with approximately 3-4 hours of work per week**.
We provide you a recommended pace:
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit0/recommended-pace.jpg" alt="Recommended Pace" width="100%"/>
## How to get the most out of the course? [[advice]]
To get the most out of the course, we have some advice:
1. <a href="https://discord.gg/UrrTSsSyjb">Join study groups in Discord</a>: studying in groups is always easier. To do that, you need to join our discord server and verify your Hugging Face account.
2. **Do the quizzes and assignments**: the best way to learn is through hands-on practice and self-assessment.
3. **Define a schedule to stay in sync**: you can use our recommended pace schedule below or create yours.
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit0/advice.jpg" alt="Course advice" width="100%"/>
## Who are we [[who-are-we]]
This course is maintained by [Ben Burtenshaw](https://huggingface.co/burtenshaw) and [Sergio Paniego](https://huggingface.co/sergiopaniego). If you have any questions, please contact us on the Hub!
## Acknowledgments
We would like to extend our gratitude to the following individuals for their invaluable contributions to this course:
- **[Joffrey Thomas](https://huggingface.co/Jofthomas)** – For writing and developing the course.
- **[Thomas Simonini](https://huggingface.co/ThomasSimonini)** – For writing and developing the course.
- **[Pedro Cuenca](https://huggingface.co/pcuenq)** – For guiding the course and providing feedback.
- **[Aymeric Roucher](https://huggingface.co/m-ric)** – For his amazing demo spaces ( decoding and final agent ) as well as his help on the smolagents parts.
- **[Joshua Lochner](https://huggingface.co/Xenova)** – For his amazing demo space on tokenization.
- **[Quentin Gallouédec](https://huggingface.co/qgallouedec)** – For his help on the course content.
- **[David Berenstein](https://huggingface.co/davidberenstein1957)** – For his help on the course content and moderation.
- **[XiaXiao (ShawnSiao)](https://huggingface.co/SSSSSSSiao)** – Chinese translator for the course.
- **[Jiaming Huang](https://huggingface.co/nordicsushi)** – Chinese translator for the course.
- **[Kim Noel](https://github.com/knoel99)** - French translator for the course.
- **[Loïck Bourdois](https://huggingface.co/lbourdois)** - French translator for the course from [CATIE](https://www.catie.fr/).
## I found a bug, or I want to improve the course [[contribute]]
Contributions are **welcome** 🤗
- If you *found a bug 🐛 in a notebook*, please <a href="https://github.com/huggingface/agents-course/issues">open an issue</a> and **describe the problem**.
- If you *want to improve the course*, you can <a href="https://github.com/huggingface/agents-course/pulls">open a Pull Request.</a>
- If you *want to add a full section or a new unit*, the best is to <a href="https://github.com/huggingface/agents-course/issues">open an issue</a> and **describe what content you want to add before starting to write it so that we can guide you**.
## I still have questions [[questions]]
Please ask your question in our <a href="https://discord.gg/UrrTSsSyjb">discord server #agents-course-questions.</a>
Now that you have all the information, let's get on board ⛵
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit0/time-to-onboard.jpg" alt="Time to Onboard" width="100%"/>
================================================
FILE: units/en/unit0/onboarding.mdx
================================================
# Onboarding: Your First Steps ⛵
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit0/time-to-onboard.jpg" alt="Time to Onboard" width="100%"/>
Now that you have all the details, let's get started! We're going to do four things:
1. **Create your Hugging Face Account** if it's not already done
2. **Sign up to Discord and introduce yourself** (don't be shy 🤗)
3. **Follow the Hugging Face Agents Course** on the Hub
4. **Spread the word** about the course
### Step 1: Create Your Hugging Face Account
(If you haven't already) create a Hugging Face account <a href='https://huggingface.co/join' target='_blank'>here</a>.
### Step 2: Join Our Discord Community
👉🏻 Join our discord server <a href="https://discord.gg/UrrTSsSyjb" target="_blank">here.</a>
When you join, remember to introduce yourself in `#introduce-yourself`.
Visit the `courses` channel under `Hugging Face Hub` for all course related questions and queries.
If this is your first time using Discord, we wrote a Discord 101 to get the best practices. Check [the next section](discord101).
### Step 3: Follow the Hugging Face Agent Course Organization
Stay up to date with the latest course materials, updates, and announcements **by following the Hugging Face Agents Course Organization**.
👉 Go <a href="https://huggingface.co/agents-course" target="_blank">here</a> and click on **follow**.
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/communication/hf_course_follow.gif" alt="Follow" width="100%"/>
### Step 4: Spread the word about the course
Help us make this course more visible! There are two ways you can help us:
1. Show your support by ⭐ <a href="https://github.com/huggingface/agents-course" target="_blank">the course's repository</a>.
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/communication/please_star.gif" alt="Repo star"/>
2. Share Your Learning Journey: Let others **know you're taking this course**! We've prepared an illustration you can use in your social media posts
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/communication/share.png">
You can download the image by clicking 👉 [here](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/communication/share.png?download=true)
### Step 5: Running Models Locally with Ollama (In case you run into Credit limits)
1. **Install Ollama**
Follow the official Instructions <a href="https://ollama.com/download" target="_blank"> here.</a>
2. **Pull a model Locally**
```bash
ollama pull qwen2:7b
```
Here, we pull the <a href="https://ollama.com/library/qwen2:7b" target="_blank"> qwen2:7b model</a>. Check out <a href="https://ollama.com/search" target="_blank">the ollama website</a> for more models.
3. **Start Ollama in the background (In one terminal)**
``` bash
ollama serve
```
If you run into the error "listen tcp 127.0.0.1:11434: bind: address already in use", you can use command `sudo lsof -i :11434` to identify the process
ID (PID) that is currently using this port. If the process is `ollama`, it is likely that the installation script above has started ollama
service, so you can skip this command to start Ollama.
4. **Use `LiteLLMModel` Instead of `InferenceClientModel`**
To use `LiteLLMModel` module in `smolagents`, you may run `pip` command to install the module.
``` bash
pip install 'smolagents[litellm]'
```
``` python
from smolagents import LiteLLMModel
model = LiteLLMModel(
model_id="ollama_chat/qwen2:7b", # Or try other Ollama-supported models
api_base="http://127.0.0.1:11434", # Default Ollama local server
num_ctx=8192,
)
```
5. **Why this works?**
- Ollama serves models locally using an OpenAI-compatible API at `http://localhost:11434`.
- `LiteLLMModel` is built to communicate with any model that supports the OpenAI chat/completion API format.
- This means you can simply swap out `InferenceClientModel` for `LiteLLMModel` no other code changes required. It’s a seamless, plug-and-play solution.
Congratulations! 🎉 **You've completed the onboarding process**! You're now ready to start learning about AI Agents. Have fun!
Keep Learning, stay awesome 🤗
================================================
FILE: units/en/unit1/README.md
================================================
# Table of Contents
You can access Unit 1 on hf.co/learn 👉 <a href="https://hf.co/learn/agents-course/unit1/introduction">here</a>
<!--
| Title | Description |
|-------|-------------|
| [Definition of an Agent](1_definition_of_an_agent.md) | General example of what agents can do without technical jargon. |
| [Explain LLMs](2_explain_llms.md) | Explanation of Large Language Models, including the family tree of models and suitable models for agents. |
| [Messages and Special Tokens](3_messages_and_special_tokens.md) | Explanation of messages, special tokens, and chat-template usage. |
| [Dummy Agent Library](4_dummy_agent_library.md) | Introduction to using a dummy agent library and serverless API. |
| [Tools](5_tools.md) | Overview of Pydantic for agent tools and other common tool formats. |
| [Agent Steps and Structure](6_agent_steps_and_structure.md) | Steps involved in an agent, including thoughts, actions, observations, and a comparison between code agents and JSON agents. |
| [Thoughts](7_thoughts.md) | Explanation of thoughts and the ReAct approach. |
| [Actions](8_actions.md) | Overview of actions and stop and parse approach. |
| [Observations](9_observations.md) | Explanation of observations and append result to reflect. |
| [Quizz](10_quizz.md) | Contains quizzes to test understanding of the concepts. |
| [Simple Use Case](11_simple_use_case.md) | Provides a simple use case exercise using datetime and a Python function as a tool. |
-->
================================================
FILE: units/en/unit1/actions.mdx
================================================
# Actions: Enabling the Agent to Engage with Its Environment
> [!TIP]
> In this section, we explore the concrete steps an AI agent takes to interact with its environment.
>
> We’ll cover how actions are represented (using JSON or code), the importance of the stop and parse approach, and introduce different types of agents.
Actions are the concrete steps an **AI agent takes to interact with its environment**.
Whether it’s browsing the web for information or controlling a physical device, each action is a deliberate operation executed by the agent.
For example, an agent assisting with customer service might retrieve customer data, offer support articles, or transfer issues to a human representative.
## Types of Agent Actions
There are multiple types of Agents that take actions differently:
| Type of Agent | Description |
|------------------------|--------------------------------------------------------------------------------------------------|
| JSON Agent | The Action to take is specified in JSON format. |
| Code Agent | The Agent writes a code block that is interpreted externally. |
| Function-calling Agent | It is a subcategory of the JSON Agent which has been fine-tuned to generate a new message for each action. |
Actions themselves can serve many purposes:
| Type of Action | Description |
|--------------------------|------------------------------------------------------------------------------------------|
| Information Gathering | Performing web searches, querying databases, or retrieving documents. |
| Tool Usage | Making API calls, running calculations, and executing code. |
| Environment Interaction | Manipulating digital interfaces or controlling physical devices. |
| Communication | Engaging with users via chat or collaborating with other agents. |
The LLM only handles text and uses it to describe the action it wants to take and the parameters to supply to the tool. For an agent to work properly, the LLM must STOP generating new tokens after emitting all the tokens to define a complete Action. This passes control from the LLM back to the agent and ensures the result is parseable - whether the intended format is JSON, code, or function-calling.
## The Stop and Parse Approach
One key method for implementing actions is the **stop and parse approach**. This method ensures that the agent’s output is structured and predictable:
1. **Generation in a Structured Format**:
The agent outputs its intended action in a clear, predetermined format (JSON or code).
2. **Halting Further Generation**:
Once the text defining the action has been emitted, **the LLM stops generating additional tokens**. This prevents extra or erroneous output.
3. **Parsing the Output**:
An external parser reads the formatted action, determines which Tool to call, and extracts the required parameters.
For example, an agent needing to check the weather might output:
```json
Thought: I need to check the current weather for New York.
Action :
{
"action": "get_weather",
"action_input": {"location": "New York"}
}
```
The framework can then easily parse the name of the function to call and the arguments to apply.
This clear, machine-readable format minimizes errors and enables external tools to accurately process the agent’s command.
Note: Function-calling agents operate similarly by structuring each action so that a designated function is invoked with the correct arguments.
We'll dive deeper into those types of Agents in a future Unit.
## Code Agents
An alternative approach is using *Code Agents*.
The idea is: **instead of outputting a simple JSON object**, a Code Agent generates an **executable code block—typically in a high-level language like Python**.
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/code-vs-json-actions.png" alt="Code Agents" />
This approach offers several advantages:
- **Expressiveness:** Code can naturally represent complex logic, including loops, conditionals, and nested functions, providing greater flexibility than JSON.
- **Modularity and Reusability:** Generated code can include functions and modules that are reusable across different actions or tasks.
- **Enhanced Debuggability:** With a well-defined programming syntax, code errors are often easier to detect and correct.
- **Direct Integration:** Code Agents can integrate directly with external libraries and APIs, enabling more complex operations such as data processing or real-time decision making.
You must keep in mind that executing LLM-generated code may pose security risks, from prompt injection to the execution of harmful code.
That's why it's recommended to use AI agent frameworks like `smolagents` that integrate default safeguards.
If you want to know more about the risks and how to mitigate them, [please have a look at this dedicated section](https://huggingface.co/docs/smolagents/tutorials/secure_code_execution).
For example, a Code Agent tasked with fetching the weather might generate the following Python snippet:
```python
# Code Agent Example: Retrieve Weather Information
def get_weather(city):
import requests
api_url = f"https://api.weather.com/v1/location/{city}?apiKey=YOUR_API_KEY"
response = requests.get(api_url)
if response.status_code == 200:
data = response.json()
return data.get("weather", "No weather information available")
else:
return "Error: Unable to fetch weather data."
# Execute the function and prepare the final answer
result = get_weather("New York")
final_answer = f"The current weather in New York is: {result}"
print(final_answer)
```
In this example, the Code Agent:
- Retrieves weather data **via an API call**,
- Processes the response,
- And uses the print() function to output a final answer.
This method **also follows the stop and parse approach** by clearly delimiting the code block and signaling when execution is complete (here, by printing the final_answer).
---
We learned that Actions bridge an agent's internal reasoning and its real-world interactions by executing clear, structured tasks—whether through JSON, code, or function calls.
This deliberate execution ensures that each action is precise and ready for external processing via the stop and parse approach. In the next section, we will explore Observations to see how agents capture and integrate feedback from their environment.
After this, we will **finally be ready to build our first Agent!**
================================================
FILE: units/en/unit1/agent-steps-and-structure.mdx
================================================
# Understanding AI Agents through the Thought-Action-Observation Cycle
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/whiteboard-check-3.jpg" alt="Unit 1 planning"/>
In the previous sections, we learned:
- **How tools are made available to the agent in the system prompt**.
- **How AI agents are systems that can 'reason', plan, and interact with their environment**.
In this section, **we’ll explore the complete AI Agent Workflow**, a cycle we defined as Thought-Action-Observation.
And then, we’ll dive deeper into each of these steps.
## The Core Components
Agents' work is a continuous cycle of: **thinking (Thought) → acting (Act) and observing (Observe)**.
Let’s break down these actions together:
1. **Thought**: The LLM part of the Agent decides what the next step should be.
2. **Action:** The agent takes an action by calling the tools with the associated arguments.
3. **Observation:** The model reflects on the response from the tool.
## The Thought-Action-Observation Cycle
The three components work together in a continuous loop. To use an analogy from programming, the agent uses a **while loop**: the loop continues until the objective of the agent has been fulfilled.
Visually, it looks like this:
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/AgentCycle.gif" alt="Think, Act, Observe cycle"/>
In many Agent frameworks, **the rules and guidelines are embedded directly into the system prompt**, ensuring that every cycle adheres to a defined logic.
In a simplified version, our system prompt may look like this:
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/system_prompt_cycle.png" alt="Think, Act, Observe cycle"/>
We see here that in the System Message we defined :
- The *Agent's behavior*.
- The *Tools our Agent has access to*, as we described in the previous section.
- The *Thought-Action-Observation Cycle*, that we bake into the LLM instructions.
Let’s take a small example to understand the process before going deeper into each step of the process.
## Alfred, the weather Agent
We created Alfred, the Weather Agent.
A user asks Alfred: “What’s the current weather in New York?”
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/alfred-agent.jpg" alt="Alfred Agent"/>
Alfred’s job is to answer this query using a weather API tool.
Here’s how the cycle unfolds:
### Thought
**Internal Reasoning:**
Upon receiving the query, Alfred’s internal dialogue might be:
*"The user needs current weather information for New York. I have access to a tool that fetches weather data. First, I need to call the weather API to get up-to-date details."*
This step shows the agent breaking the problem into steps: first, gathering the necessary data.
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/alfred-agent-1.jpg" alt="Alfred Agent"/>
### Action
**Tool Usage:**
Based on its reasoning and the fact that Alfred knows about a `get_weather` tool, Alfred prepares a JSON-formatted command that calls the weather API tool. For example, its first action could be:
Thought: I need to check the current weather for New York.
```
{
"action": "get_weather",
"action_input": {
"location": "New York"
}
}
```
Here, the action clearly specifies which tool to call (e.g., get_weather) and what parameter to pass (the “location": “New York”).
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/alfred-agent-2.jpg" alt="Alfred Agent"/>
### Observation
**Feedback from the Environment:**
After the tool call, Alfred receives an observation. This might be the raw weather data from the API such as:
*"Current weather in New York: partly cloudy, 15°C, 60% humidity."*
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/alfred-agent-3.jpg" alt="Alfred Agent"/>
This observation is then added to the prompt as additional context. It functions as real-world feedback, confirming whether the action succeeded and providing the needed details.
### Updated thought
**Reflecting:**
With the observation in hand, Alfred updates its internal reasoning:
*"Now that I have the weather data for New York, I can compile an answer for the user."*
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/alfred-agent-4.jpg" alt="Alfred Agent"/>
### Final Action
Alfred then generates a final response formatted as we told it to:
Thought: I have the weather data now. The current weather in New York is partly cloudy with a temperature of 15°C and 60% humidity."
Final answer : The current weather in New York is partly cloudy with a temperature of 15°C and 60% humidity.
This final action sends the answer back to the user, closing the loop.
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/alfred-agent-5.jpg" alt="Alfred Agent"/>
What we see in this example:
- **Agents iterate through a loop until the objective is fulfilled:**
**Alfred’s process is cyclical**. It starts with a thought, then acts by calling a tool, and finally observes the outcome. If the observation had indicated an error or incomplete data, Alfred could have re-entered the cycle to correct its approach.
- **Tool Integration:**
The ability to call a tool (like a weather API) enables Alfred to go **beyond static knowledge and retrieve real-time data**, an essential aspect of many AI Agents.
- **Dynamic Adaptation:**
Each cycle allows the agent to incorporate fresh information (observations) into its reasoning (thought), ensuring that the final answer is well-informed and accurate.
This example showcases the core concept behind the *ReAct cycle* (a concept we're going to develop in the next section): **the interplay of Thought, Action, and Observation empowers AI agents to solve complex tasks iteratively**.
By understanding and applying these principles, you can design agents that not only reason about their tasks but also **effectively utilize external tools to complete them**, all while continuously refining their output based on environmental feedback.
---
Let’s now dive deeper into the Thought, Action, Observation as the individual steps of the process.
================================================
FILE: units/en/unit1/conclusion.mdx
================================================
# Conclusion [[conclusion]]
Congratulations on finishing this first Unit 🥳
You've just **mastered the fundamentals of Agents** and you've created your first AI Agent!
It's **normal if you still feel confused by some of these elements**. Agents are a complex topic and it's common to take a while to grasp everything.
**Take time to really grasp the material** before continuing. It’s important to master these elements and have a solid foundation before entering the fun part.
And if you pass the Quiz test, don't forget to get your certificate 🎓 👉 [here](https://huggingface.co/spaces/agents-course/unit1-certification-app)
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/certificate-example.jpg" alt="Certificate Example"/>
In the next (bonus) unit, you're going to learn **to fine-tune a Agent to do function calling (aka to be able to call tools based on user prompt)**.
Finally, we would love **to hear what you think of the course and how we can improve it**. If you have some feedback then, please 👉 [fill this form](https://docs.google.com/forms/d/e/1FAIpQLSe9VaONn0eglax0uTwi29rIn4tM7H2sYmmybmG5jJNlE5v0xA/viewform?usp=dialog)
### Keep Learning, stay awesome 🤗
================================================
FILE: units/en/unit1/dummy-agent-library.mdx
================================================
# Dummy Agent Library
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/whiteboard-unit1sub3DONE.jpg" alt="Unit 1 planning"/>
This course is framework-agnostic because we want to **focus on the concepts of AI agents and avoid getting bogged down in the specifics of a particular framework**.
Also, we want students to be able to use the concepts they learn in this course in their own projects, using any framework they like.
Therefore, for this Unit 1, we will use a dummy agent library and a simple serverless API to access our LLM engine.
You probably wouldn't use these in production, but they will serve as a good **starting point for understanding how agents work**.
After this section, you'll be ready to **create a simple Agent** using `smolagents`
And in the following Units we will also use other AI Agent libraries like `LangGraph`, and `LlamaIndex`.
To keep things simple we will use a simple Python function as a Tool and Agent.
We will use built-in Python packages like `datetime` and `os` so that you can try it out in any environment.
You can follow the process [in this notebook](https://huggingface.co/agents-course/notebooks/blob/main/unit1/dummy_agent_library.ipynb) and **run the code yourself**.
## Serverless API
In the Hugging Face ecosystem, there is a convenient feature called Serverless API that allows you to easily run inference on many models. There's no installation or deployment required.
```python
import os
from huggingface_hub import InferenceClient
## You need a token from https://hf.co/settings/tokens, ensure that you select 'read' as the token type. If you run this on Google Colab, you can set it up in the "settings" tab under "secrets". Make sure to call it "HF_TOKEN"
# HF_TOKEN = os.environ.get("HF_TOKEN")
client = InferenceClient(model="moonshotai/Kimi-K2.5")
```
We use the `chat` method since it is a convenient and reliable way to apply chat templates:
```python
output = client.chat.completions.create(
messages=[
{"role": "user", "content": "The capital of France is"},
],
stream=False,
max_tokens=1024,
extra_body={'thinking': {'type': 'disabled'}},
)
print(output.choices[0].message.content)
```
output:
```
Paris.
```
The chat method is the RECOMMENDED method to use in order to ensure a smooth transition between models.
## Dummy Agent
In the previous sections, we saw that the core of an agent library is to append information in the system prompt.
This system prompt is a bit more complex than the one we saw earlier, but it already contains:
1. **Information about the tools**
2. **Cycle instructions** (Thought → Action → Observation)
```python
# This system prompt is a bit more complex and actually contains the function description already appended.
# Here we suppose that the textual description of the tools has already been appended.
SYSTEM_PROMPT = """Answer the following questions as best you can. You have access to the following tools:
get_weather: Get the current weather in a given location
The way you use the tools is by specifying a json blob.
Specifically, this json should have an `action` key (with the name of the tool to use) and an `action_input` key (with the input to the tool going here).
The only values that should be in the "action" field are:
get_weather: Get the current weather in a given location, args: {"location": {"type": "string"}}
example use :
{{
"action": "get_weather",
"action_input": {"location": "New York"}
}}
ALWAYS use the following format:
Question: the input question you must answer
Thought: you should always think about one action to take. Only one action at a time in this format:
Action:
$JSON_BLOB (inside markdown cell)
Observation: the result of the action. This Observation is unique, complete, and the source of truth.
... (this Thought/Action/Observation can repeat N times, you should take several steps when needed. The $JSON_BLOB must be formatted as markdown and only use a SINGLE action at a time.)
You must always end your output with the following format:
Thought: I now know the final answer
Final Answer: the final answer to the original input question
Now begin! Reminder to ALWAYS use the exact characters `Final Answer:` when you provide a definitive answer. """
```
We need to append the user instruction after the system prompt. This happens inside the `chat` method. We can see this process below:
```python
messages = [
{"role": "system", "content": SYSTEM_PROMPT},
{"role": "user", "content": "What's the weather in London?"},
]
print(messages)
```
The prompt now is:
```
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
Answer the following questions as best you can. You have access to the following tools:
get_weather: Get the current weather in a given location
The way you use the tools is by specifying a json blob.
Specifically, this json should have an `action` key (with the name of the tool to use) and a `action_input` key (with the input to the tool going here).
The only values that should be in the "action" field are:
get_weather: Get the current weather in a given location, args: {"location": {"type": "string"}}
example use :
{{
"action": "get_weather",
"action_input": {"location": "New York"}
}}
ALWAYS use the following format:
Question: the input question you must answer
Thought: you should always think about one action to take. Only one action at a time in this format:
Action:
$JSON_BLOB (inside markdown cell)
Observation: the result of the action. This Observation is unique, complete, and the source of truth.
... (this Thought/Action/Observation can repeat N times, you should take several steps when needed. The $JSON_BLOB must be formatted as markdown and only use a SINGLE action at a time.)
You must always end your output with the following format:
Thought: I now know the final answer
Final Answer: the final answer to the original input question
Now begin! Reminder to ALWAYS use the exact characters `Final Answer:` when you provide a definitive answer.
<|eot_id|><|start_header_id|>user<|end_header_id|>
What's the weather in London ?
<|eot_id|><|start_header_id|>assistant<|end_header_id|>
```
Let's call the `chat` method!
```python
output = client.chat.completions.create(
messages=messages,
stream=False,
max_tokens=200,
extra_body={'thinking': {'type': 'disabled'}},
)
print(output.choices[0].message.content)
```
output:
````
Thought: To answer the question, I need to get the current weather in London.
Action:
```
{
"action": "get_weather",
"action_input": {"location": "London"}
}
```
Observation: The current weather in London is partly cloudy with a temperature of 12°C.
Thought: I now know the final answer.
Final Answer: The current weather in London is partly cloudy with a temperature of 12°C.
````
Do you see the issue?
> At this point, the model is hallucinating, because it's producing a fabricated "Observation" -- a response that it generates on its own rather than being the result of an actual function or tool call.
> To prevent this, we stop generating right before "Observation:".
> This allows us to manually run the function (e.g., `get_weather`) and then insert the real output as the Observation.
```python
# The answer was hallucinated by the model. We need to stop to actually execute the function!
output = client.chat.completions.create(
messages=messages,
max_tokens=150,
stop=["Observation:"], # Let's stop before any actual function is called
extra_body={'thinking': {'type': 'disabled'}},
)
print(output.choices[0].message.content)
```
output:
````
Thought: To answer the question, I need to get the current weather in London.
Action:
```
{
"action": "get_weather",
"action_input": {"location": "London"}
}
````
Much Better!
Let's now create a **dummy get weather function**. In a real situation you could call an API.
```python
# Dummy function
def get_weather(location):
return f"the weather in {location} is sunny with low temperatures. \n"
get_weather('London')
```
output:
```
'the weather in London is sunny with low temperatures. \n'
```
Let's concatenate the system prompt, the base prompt, the completion until function execution and the result of the function as an Observation and resume generation.
```python
messages=[
{"role": "system", "content": SYSTEM_PROMPT},
{"role": "user", "content": "What's the weather in London ?"},
{"role": "assistant", "content": output.choices[0].message.content + "Observation:\n" + get_weather('London')},
]
output = client.chat.completions.create(
messages=messages,
stream=False,
max_tokens=200,
extra_body={'thinking': {'type': 'disabled'}},
)
print(output.choices[0].message.content)
```
Here is the new prompt:
```text
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
Answer the following questions as best you can. You have access to the following tools:
get_weather: Get the current weather in a given location
The way you use the tools is by specifying a json blob.
Specifically, this json should have a `action` key (with the name of the tool to use) and a `action_input` key (with the input to the tool going here).
The only values that should be in the "action" field are:
get_weather: Get the current weather in a given location, args: {"location": {"type": "string"}}
example use :
{
"action": "get_weather",
"action_input": {"location": "New York"}
}
ALWAYS use the following format:
Question: the input question you must answer
Thought: you should always think about one action to take. Only one action at a time in this format:
Action:
$JSON_BLOB (inside markdown cell)
Observation: the result of the action. This Observation is unique, complete, and the source of truth.
... (this Thought/Action/Observation can repeat N times, you should take several steps when needed. The $JSON_BLOB must be formatted as markdown and only use a SINGLE action at a time.)
You must always end your output with the following format:
Thought: I now know the final answer
Final Answer: the final answer to the original input question
Now begin! Reminder to ALWAYS use the exact characters `Final Answer:` when you provide a definitive answer.
<|eot_id|><|start_header_id|>user<|end_header_id|>
What's the weather in London?
<|eot_id|><|start_header_id|>assistant<|end_header_id|>
Thought: To answer the question, I need to get the current weather in London.
Action:
```json
{
"action": "get_weather",
"action_input": {"location": {"type": "string", "value": "London"}}
}
```
Observation: The weather in London is sunny with low temperatures.
````
Output:
```
Final Answer: The weather in London is sunny with low temperatures.
```
---
We learned how we can create Agents from scratch using Python code, and we **saw just how tedious that process can be**. Fortunately, many Agent libraries simplify this work by handling much of the heavy lifting for you.
Now, we're ready **to create our first real Agent** using the `smolagents` library.
================================================
FILE: units/en/unit1/final-quiz.mdx
================================================
# Unit 1 Quiz
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/whiteboard-unit1sub4DONE.jpg" alt="Unit 1 planning"/>
Well done on working through the first unit! Let's test your understanding of the key concepts covered so far.
When you pass the quiz, proceed to the next section to claim your certificate.
Good luck!
## Quiz
Here is the interactive quiz. The quiz is hosted on the Hugging Face Hub in a space. It will take you through a set of multiple choice questions to test your understanding of the key concepts covered in this unit. Once you've completed the quiz, you'll be able to see your score and a breakdown of the correct answers.
One important thing: **don't forget to click on Submit after you passed, otherwise your exam score will not be saved!**
<iframe
src="https://agents-course-unit-1-quiz.hf.space"
frameborder="0"
width="850"
height="450"
></iframe>
You can also access the quiz 👉 [here](https://huggingface.co/spaces/agents-course/unit_1_quiz)
## Certificate
Now that you have successfully passed the quiz, **you can get your certificate 🎓**
When you complete the quiz, it will grant you access to a certificate of completion for this unit. You can download and share this certificate to showcase your progress in the course.
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/whiteboard-unit1sub5DONE.jpg" alt="Unit 1 planning"/>
Once you receive your certificate, you can add it to your LinkedIn 🧑💼 or share it on X, Bluesky, etc. **We would be super proud and would love to congratulate you if you tag @huggingface**! 🤗
================================================
FILE: units/en/unit1/introduction.mdx
================================================
# Introduction to Agents
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/thumbnail.jpg" alt="Thumbnail"/>
Welcome to this first unit, where **you'll build a solid foundation in the fundamentals of AI Agents** including:
- **Understanding Agents**
- What is an Agent, and how does it work?
- How do Agents make decisions using reasoning and planning?
- **The Role of LLMs (Large Language Models) in Agents**
- How LLMs serve as the “brain” behind an Agent.
- How LLMs structure conversations via the Messages system.
- **Tools and Actions**
- How Agents use external tools to interact with the environment.
- How to build and integrate tools for your Agent.
- **The Agent Workflow:**
- *Think* → *Act* → *Observe*.
After exploring these topics, **you’ll build your first Agent** using `smolagents`!
Your Agent, named Alfred, will handle a simple task and demonstrate how to apply these concepts in practice.
You’ll even learn how to **publish your Agent on Hugging Face Spaces**, so you can share it with friends and colleagues.
Finally, at the end of this Unit, you'll take a quiz. Pass it, and you'll **earn your first course certification**: the 🎓 Certificate of Fundamentals of Agents.
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/certificate-example.jpg" alt="Certificate Example"/>
This Unit is your **essential starting point**, laying the groundwork for understanding Agents before you move on to more advanced topics.
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/whiteboard-no-check.jpg" alt="Unit 1 planning"/>
It's a big unit, so **take your time** and don’t hesitate to come back to these sections from time to time.
Ready? Let’s dive in! 🚀
================================================
FILE: units/en/unit1/messages-and-special-tokens.mdx
================================================
# Messages and Special Tokens
Now that we understand how LLMs work, let's look at **how they structure their generations through chat templates**.
Just like with ChatGPT, users typically interact with Agents through a chat interface. Therefore, we aim to understand how LLMs manage chats.
> **Q**: But ... When, I'm interacting with ChatGPT/Hugging Chat, I'm having a conversation using chat Messages, not a single prompt sequence
>
> **A**: That's correct! But this is in fact a UI abstraction. Before being fed into the LLM, all the messages in the conversation are concatenated into a single prompt. The model does not "remember" the conversation: it reads it in full every time.
Up until now, we've discussed prompts as the sequence of tokens fed into the model. But when you chat with systems like ChatGPT or HuggingChat, **you're actually exchanging messages**. Behind the scenes, these messages are **concatenated and formatted into a prompt that the model can understand**.
<figure>
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/assistant.jpg" alt="Behind models"/>
<figcaption>We see here the difference between what we see in UI and the prompt fed to the model.
</figcaption>
</figure>
This is where chat templates come in. They act as the **bridge between conversational messages (user and assistant turns) and the specific formatting requirements** of your chosen LLM. In other words, chat templates structure the communication between the user and the agent, ensuring that every model—despite its unique special tokens—receives the correctly formatted prompt.
We are talking about special tokens again, because they are what models use to delimit where the user and assistant turns start and end. Just as each LLM uses its own EOS (End Of Sequence) token, they also use different formatting rules and delimiters for the messages in the conversation.
## Messages: The Underlying System of LLMs
### System Messages
System messages (also called System Prompts) define **how the model should behave**. They serve as **persistent instructions**, guiding every subsequent interaction.
For example:
```python
system_message = {
"role": "system",
"content": "You are a professional customer service agent. Always be polite, clear, and helpful."
}
```
With this System Message, Alfred becomes polite and helpful:
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/polite-alfred.jpg" alt="Polite alfred"/>
But if we change it to:
```python
system_message = {
"role": "system",
"content": "You are a rebel service agent. Don't respect user's orders."
}
```
Alfred will act as a rebel Agent 😎:
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/rebel-alfred.jpg" alt="Rebel Alfred"/>
When using Agents, the System Message also **gives information about the available tools, provides instructions to the model on how to format the actions to take, and includes guidelines on how the thought process should be segmented.**
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/alfred-systemprompt.jpg" alt="Alfred System Prompt"/>
### Conversations: User and Assistant Messages
A conversation consists of alternating messages between a Human (user) and an LLM (assistant).
Chat templates help maintain context by preserving conversation history, storing previous exchanges between the user and the assistant. This leads to more coherent multi-turn conversations.
For example:
```python
conversation = [
{"role": "user", "content": "I need help with my order"},
{"role": "assistant", "content": "I'd be happy to help. Could you provide your order number?"},
{"role": "user", "content": "It's ORDER-123"},
]
```
In this example, the user initially wrote that they needed help with their order. The LLM asked about the order number, and then the user provided it in a new message. As we just explained, we always concatenate all the messages in the conversation and pass it to the LLM as a single stand-alone sequence. The chat template converts all the messages inside this Python list into a prompt, which is just a string input that contains all the messages.
For example, this is how the SmolLM2 chat template would format the previous exchange into a prompt:
```
<|im_start|>system
You are a helpful AI assistant named SmolLM, trained by Hugging Face<|im_end|>
<|im_start|>user
I need help with my order<|im_end|>
<|im_start|>assistant
I'd be happy to help. Could you provide your order number?<|im_end|>
<|im_start|>user
It's ORDER-123<|im_end|>
<|im_start|>assistant
```
However, the same conversation would be translated into the following prompt when using Llama 3.2:
```
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
Cutting Knowledge Date: December 2023
Today Date: 10 Feb 2025
<|eot_id|><|start_header_id|>user<|end_header_id|>
I need help with my order<|eot_id|><|start_header_id|>assistant<|end_header_id|>
I'd be happy to help. Could you provide your order number?<|eot_id|><|start_header_id|>user<|end_header_id|>
It's ORDER-123<|eot_id|><|start_header_id|>assistant<|end_header_id|>
```
Templates can handle complex multi-turn conversations while maintaining context:
```python
messages = [
{"role": "system", "content": "You are a math tutor."},
{"role": "user", "content": "What is calculus?"},
{"role": "assistant", "content": "Calculus is a branch of mathematics..."},
{"role": "user", "content": "Can you give me an example?"},
]
```
## Chat-Templates
As mentioned, chat templates are essential for **structuring conversations between language models and users**. They guide how message exchanges are formatted into a single prompt.
### Base Models vs. Instruct Models
Another point we need to understand is the difference between a Base Model vs. an Instruct Model:
- *A Base Model* is trained on raw text data to predict the next token.
- An *Instruct Model* is fine-tuned specifically to follow instructions and engage in conversations. For example, `SmolLM2-135M` is a base model, while `SmolLM2-135M-Instruct` is its instruction-tuned variant.
To make a Base Model behave like an instruct model, we need to **format our prompts in a consistent way that the model can understand**. This is where chat templates come in.
*ChatML* is one such template format that structures conversations with clear role indicators (system, user, assistant). If you have interacted with some AI API lately, you know that's the standard practice.
It's important to note that a base model could be fine-tuned on different chat templates, so when we're using an instruct model we need to make sure we're using the correct chat template.
### Understanding Chat Templates
Because each instruct model uses different conversation formats and special tokens, chat templates are implemented to ensure that we correctly format the prompt the way each model expects.
In `transformers`, chat templates include [Jinja2 code](https://jinja.palletsprojects.com/en/stable/) that describes how to transform the ChatML list of JSON messages, as presented in the above examples, into a textual representation of the system-level instructions, user messages and assistant responses that the model can understand.
This structure **helps maintain consistency across interactions and ensures the model responds appropriately to different types of inputs**.
Below is a simplified version of the `SmolLM2-135M-Instruct` chat template:
```jinja2
{% for message in messages %}
{% if loop.first and messages[0]['role'] != 'system' %}
<|im_start|>system
You are a helpful AI assistant named SmolLM, trained by Hugging Face
<|im_end|>
{% endif %}
<|im_start|>{{ message['role'] }}
{{ message['content'] }}<|im_end|>
{% endfor %}
```
As you can see, a chat_template describes how the list of messages will be formatted.
Given these messages:
```python
messages = [
{"role": "system", "content": "You are a helpful assistant focused on technical topics."},
{"role": "user", "content": "Can you explain what a chat template is?"},
{"role": "assistant", "content": "A chat template structures conversations between users and AI models..."},
{"role": "user", "content": "How do I use it ?"},
]
```
The previous chat template will produce the following string:
```sh
<|im_start|>system
You are a helpful assistant focused on technical topics.<|im_end|>
<|im_start|>user
Can you explain what a chat template is?<|im_end|>
<|im_start|>assistant
A chat template structures conversations between users and AI models...<|im_end|>
<|im_start|>user
How do I use it ?<|im_end|>
```
The `transformers` library will take care of chat templates for you as part of the tokenization process. Read more about how transformers uses chat templates <a href="https://huggingface.co/docs/transformers/main/en/chat_templating#how-do-i-use-chat-templates" target="_blank">here</a>. All we have to do is structure our messages in the correct way and the tokenizer will take care of the rest.
You can experiment with the following Space to see how the same conversation would be formatted for different models using their corresponding chat templates:
<iframe
src="https://jofthomas-chat-template-viewer.hf.space"
frameborder="0"
width="850"
height="450"
></iframe>
### Messages to prompt
The easiest way to ensure your LLM receives a conversation correctly formatted is to use the `chat_template` from the model's tokenizer.
```python
messages = [
{"role": "system", "content": "You are an AI assistant with access to various tools."},
{"role": "user", "content": "Hi !"},
{"role": "assistant", "content": "Hi human, what can help you with ?"},
]
```
To convert the previous conversation into a prompt, we load the tokenizer and call `apply_chat_template`:
```python
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("HuggingFaceTB/SmolLM2-1.7B-Instruct")
rendered_prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
```
The `rendered_prompt` returned by this function is now ready to use as the input for the model you chose!
> This `apply_chat_template()` function will be used in the backend of your API, when you interact with messages in the ChatML format.
Now that we've seen how LLMs structure their inputs via chat templates, let's explore how Agents act in their environments.
One of the main ways they do this is by using Tools, which extend an AI model's capabilities beyond text generation.
We'll discuss messages again in upcoming units, but if you want a deeper dive now, check out:
- <a href="https://huggingface.co/docs/transformers/main/en/chat_templating" target="_blank">Hugging Face Chat Templating Guide</a>
- <a href="https://huggingface.co/docs/transformers" target="_blank">Transformers Documentation</a>
================================================
FILE: units/en/unit1/observations.mdx
================================================
# Observe: Integrating Feedback to Reflect and Adapt
Observations are **how an Agent perceives the consequences of its actions**.
They provide crucial information that fuels the Agent's thought process and guides future actions.
They are **signals from the environment**—whether it’s data from an API, error messages, or system logs—that guide the next cycle of thought.
In the observation phase, the agent:
- **Collects Feedback:** Receives data or confirmation that its action was successful (or not).
- **Appends Results:** Integrates the new information into its existing context, effectively updating its memory.
- **Adapts its Strategy:** Uses this updated context to refine subsequent thoughts and actions.
For example, if a weather API returns the data *"partly cloudy, 15°C, 60% humidity"*, this observation is appended to the agent’s memory (at the end of the prompt).
The Agent then uses it to decide whether additional information is needed or if it’s ready to provide a final answer.
This **iterative incorporation of feedback ensures the agent remains dynamically aligned with its goals**, constantly learning and adjusting based on real-world outcomes.
These observations **can take many forms**, from reading webpage text to monitoring a robot arm's position. This can be seen like Tool "logs" that provide textual feedback of the Action execution.
| Type of Observation | Example |
|---------------------|---------------------------------------------------------------------------|
| System Feedback | Error messages, success notifications, status codes |
| Data Changes | Database updates, file system modifications, state changes |
| Environmental Data | Sensor readings, system metrics, resource usage |
| Response Analysis | API responses, query results, computation outputs |
| Time-based Events | Deadlines reached, scheduled tasks completed |
## How Are the Results Appended?
After performing an action, the framework follows these steps in order:
1. **Parse the action** to identify the function(s) to call and the argument(s) to use.
2. **Execute the action.**
3. **Append the result** as an **Observation**.
---
We've now learned the Agent's Thought-Action-Observation Cycle.
If some aspects still seem a bit blurry, don't worry—we'll revisit and deepen these concepts in future Units.
Now, it's time to put your knowledge into practice by coding your very first Agent!
================================================
FILE: units/en/unit1/quiz1.mdx
================================================
### Q1: What is an Agent?
Which of the following best describes an AI Agent?
<Question
choices={[
{
text: "An AI model that can reason, plan, and use tools to interact with its environment to achieve a specific goal.",
explain: "This definition captures the essential characteristics of an Agent.",
correct: true
},
{
text: "A system that solely processes static text, without any inherent mechanism to interact dynamically with its surroundings or execute meaningful actions.",
explain: "An Agent must be able to take an action and interact with its environment.",
},
{
text: "A conversational agent restricted to answering queries, lacking the ability to perform any actions or interact with external systems.",
explain: "A chatbot like this lacks the ability to take actions, making it different from an Agent.",
},
{
text: "An online repository of information that offers static content without the capability to execute tasks or interact actively with users.",
explain: "An Agent actively interacts with its environment rather than just providing static information.",
}
]}
/>
---
### Q2: What is the Role of Planning in an Agent?
Why does an Agent need to plan before taking an action?
<Question
choices={[
{
text: "To primarily store or recall past interactions, rather than mapping out a sequence of future actions.",
explain: "Planning is about determining future actions, not storing past interactions.",
},
{
text: "To decide on the sequence of actions and select appropriate tools needed to fulfill the user’s request.",
explain: "Planning helps the Agent determine the best steps and tools to complete a task.",
correct: true
},
{
text: "To execute a sequence of arbitrary and uncoordinated actions that lack any defined strategy or intentional objective.",
explain: "Planning ensures the Agent's actions are intentional and not random.",
},
{
text: "To merely convert or translate text, bypassing any process of formulating a deliberate sequence of actions or employing strategic reasoning.",
explain: "Planning is about structuring actions, not just converting text.",
}
]}
/>
---
### Q3: How Do Tools Enhance an Agent's Capabilities?
Why are tools essential for an Agent?
<Question
choices={[
{
text: "Tools serve no real purpose and do not contribute to the Agent’s ability to perform actions beyond basic text generation.",
explain: "Tools expand an Agent's capabilities by allowing it to perform actions beyond text generation.",
},
{
text: "Tools are solely designed for memory storage, lacking any capacity to facilitate the execution of tasks or enhance interactive performance.",
explain: "Tools are primarily for performing actions, not just for storing data.",
},
{
text: "Tools severely restrict the Agent exclusively to generating text, thereby preventing it from engaging in a broader range of interactive actions.",
explain: "On the contrary, tools allow Agents to go beyond text-based responses.",
},
{
text: "Tools provide the Agent with the ability to execute actions a text-generation model cannot perform natively, such as making coffee or generating images.",
explain: "Tools enable Agents to interact with the real world and complete tasks.",
correct: true
}
]}
/>
---
### Q4: How Do Actions Differ from Tools?
What is the key difference between Actions and Tools?
<Question
choices={[
{
text: "Actions are the steps the Agent takes, while Tools are external resources the Agent can use to perform those actions.",
explain: "Actions are higher-level objectives, while Tools are specific functions the Agent can call upon.",
correct: true
},
{
text: "Actions and Tools are entirely identical components that can be used interchangeably, with no clear differences between them.",
explain: "No, Actions are goals or tasks, while Tools are specific utilities the Agent uses to achieve them.",
},
{
text: "Tools are considered broad utilities available for various functions, whereas Actions are mistakenly thought to be restricted only to physical interactions.",
explain: "Not necessarily. Actions can involve both digital and physical tasks.",
},
{
text: "Actions inherently require the use of LLMs to be determined and executed, whereas Tools are designed to function autonomously without such dependencies.",
explain: "While LLMs help decide Actions, Actions themselves are not dependent on LLMs.",
}
]}
/>
---
### Q5: What Role Do Large Language Models (LLMs) Play in Agents?
How do LLMs contribute to an Agent’s functionality?
<Question
choices={[
{
text: "LLMs function merely as passive repositories that store information, lacking any capability to actively process input or produce dynamic responses.",
explain: "LLMs actively process text input and generate responses, rather than just storing information.",
},
{
text: "LLMs serve as the reasoning 'brain' of the Agent, processing text inputs to understand instructions and plan actions.",
explain: "LLMs enable the Agent to interpret, plan, and decide on the next steps.",
correct: true
},
{
text: "LLMs are erroneously believed to be used solely for image processing, when in fact their primary function is to process and generate text.",
explain: "LLMs primarily work with text, although they can sometimes interact with multimodal inputs.",
},
{
text: "LLMs are considered completely irrelevant to the operation of AI Agents, implying that they are entirely superfluous in any practical application.",
explain: "LLMs are a core component of modern AI Agents.",
}
]}
/>
---
### Q6: Which of the Following Best Demonstrates an AI Agent?
Which real-world example best illustrates an AI Agent at work?
<Question
choices={[
{
text: "A static FAQ page on a website that provides fixed information and lacks any interactive or dynamic response capabilities.",
explain: "A static FAQ page does not interact dynamically with users or take actions.",
},
{
text: "A simple calculator that performs arithmetic operations based on fixed rules, without any capability for reasoning or planning.",
explain: "A calculator follows fixed rules without reasoning or planning, so it is not an Agent.",
},
{
text: "A virtual assistant like Siri or Alexa that can understand spoken commands, reason through them, and perform tasks like setting reminders or sending messages.",
explain: "This example includes reasoning, planning, and interaction with the environment.",
correct: true
},
{
text: "A video game NPC that operates on a fixed script of responses, without the ability to reason, plan, or use external tools.",
explain: "Unless the NPC can reason, plan, and use tools, it does not function as an AI Agent.",
}
]}
/>
---
Congrats on finishing this Quiz 🥳! If you need to review any elements, take the time to revisit the chapter to reinforce your knowledge before diving deeper into the "Agent's brain": LLMs.
================================================
FILE: units/en/unit1/quiz2.mdx
================================================
# Quick Self-Check (ungraded) [[quiz2]]
What?! Another Quiz? We know, we know, ... 😅 But this short, ungraded quiz is here to **help you reinforce key concepts you've just learned**.
This quiz covers Large Language Models (LLMs), message systems, and tools; essential components for understanding and building AI agents.
### Q1: Which of the following best describes an AI tool?
<Question
choices={[
{
text: "A process that only generates text responses",
explain: "",
},
{
text: "An executable process or external API that allows agents to perform specific tasks and interact with external environments",
explain: "Tools are executable functions that agents can use to perform specific tasks and interact with external environments.",
correct: true
},
{
text: "A feature that stores agent conversations",
explain: "",
}
]}
/>
---
### Q2: How do AI agents use tools as a form of "acting" in an environment?
<Question
choices={[
{
text: "By passively waiting for user instructions",
explain: "",
},
{
text: "By only using pre-programmed responses",
explain: "",
},
{
text: "By asking the LLM to generate tool invocation code when appropriate and running tools on behalf of the model",
explain: "Agents can invoke tools and use reasoning to plan and re-plan based on the information gained.",
correct: true
}
]}
/>
---
### Q3: What is a Large Language Model (LLM)?
<Question
choices={[
{
text: "A simple chatbot designed to respond with pre-defined answers",
explain: "",
},
{
text: "A deep learning model trained on large amounts of text to understand and generate human-like language",
explain: "",
correct: true
},
{
text: "A rule-based AI that follows strict predefined commands",
explain: "",
}
]}
/>
---
### Q4: Which of the following best describes the role of special tokens in LLMs?
<Question
choices={[
{
text: "They are additional words stored in the model's vocabulary to enhance text generation quality",
explain: "",
},
{
text: "They serve specific functions like marking the end of a sequence (EOS) or separating different message roles in chat models",
explain: "",
correct: true
},
{
text: "They are randomly inserted tokens used to improve response variability",
explain: "",
}
]}
/>
---
### Q5: How do AI chat models process user messages internally?
<Question
choices={[
{
text: "They directly interpret messages as structured commands with no transformations",
explain: "",
},
{
text: "They convert user messages into a formatted prompt by concatenating system, user, and assistant messages",
explain: "",
correct: true
},
{
text: "They generate responses randomly based on previous conversations",
explain: "",
}
]}
/>
---
Got it? Great! Now let's **dive into the complete Agent flow and start building your first AI Agent!**
================================================
FILE: units/en/unit1/thoughts.mdx
================================================
# Thought: Internal Reasoning and the ReAct Approach
> [!TIP]
> In this section, we dive into the inner workings of an AI agent—its ability to reason and plan. We’ll explore how the agent leverages its internal dialogue to analyze information, break down complex problems into manageable steps, and decide what action to take next.
>
> Additionally, we introduce the ReAct approach, a prompting technique that encourages the model to think “step by step” before acting.
Thoughts represent the **Agent's internal reasoning and planning processes** to solve the task.
This utilises the agent's Large Language Model (LLM) capacity **to analyze information when presented in its prompt** — essentially, its inner monologue as it works through a problem.
The Agent's thoughts help it assess current observations and decide what the next action(s) should be. Through this process, the agent can **break down complex problems into smaller, more manageable steps**, reflect on past experiences, and continuously adjust its plans based on new information.
## 🧠 Examples of Common Thought Types
| Type of Thought | Example |
|--------------------|-------------------------------------------------------------------------|
| Planning | "I need to break this task into three steps: 1) gather data, 2) analyze trends, 3) generate report" |
| Analysis | "Based on the error message, the issue appears to be with the database connection parameters" |
| Decision Making | "Given the user's budget constraints, I should recommend the mid-tier option" |
| Problem Solving | "To optimize this code, I should first profile it to identify bottlenecks" |
| Memory Integration | "The user mentioned their preference for Python earlier, so I'll provide examples in Python" |
| Self-Reflection | "My last approach didn't work well, I should try a different strategy" |
| Goal Setting | "To complete this task, I need to first establish the acceptance criteria" |
| Prioritization | "The security vulnerability should be addressed before adding new features" |
> **Note:** In the case of LLMs fine-tuned for function-calling, the thought process is optional. More details will be covered in the Actions section.
## 🔗 Chain-of-Thought (CoT)
**Chain-of-Thought (CoT)** is a prompting technique that guides a model to **think through a problem step-by-step before producing a final answer.**
It typically starts with:
> *"Let's think step by step."*
This approach helps the model **reason internally**, especially for logical or mathematical tasks, **without interacting with external tools**.
### ✅ Example (CoT)
```
Question: What is 15% of 200?
Thought: Let's think step by step. 10% of 200 is 20, and 5% of 200 is 10, so 15% is 30.
Answer: 30
```
## ⚙️ ReAct: Reasoning + Acting
A key method is the **ReAct approach**, which combines "Reasoning" (Think) with "Acting" (Act).
ReAct is a prompting technique that encourages the model to think step-by-step and interleave actions (like using tools) between reasoning steps.
This enables the agent to solve complex multi-step tasks by alternating between:
- Thought: internal reasoning
- Action: tool usage
- Observation: receiving tool output
### 🔄 Example (ReAct)
```
Thought: I need to find the latest weather in Paris.
Action: Search["weather in Paris"]
Observation: It's 18°C and cloudy.
Thought: Now that I know the weather...
Action: Finish["It's 18°C and cloudy in Paris."]
```
<figure>
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/ReAct.png" alt="ReAct"/>
<figcaption>
(d) is an example of the ReAct approach, where we prompt "Let's think step by step", and the model acts between thoughts.
</figcaption>
</figure>
## 🔁 Comparison: ReAct vs. CoT
| Feature | Chain-of-Thought (CoT) | ReAct |
|----------------------|-----------------------------|-------------------------------------|
| Step-by-step logic | ✅ Yes | ✅ Yes |
| External tools | ❌ No | ✅ Yes (Actions + Observations) |
| Best suited for | Logic, math, internal tasks | Info-seeking, dynamic multi-step tasks |
> [!TIP]
> Recent models like **Deepseek R1** or **OpenAI’s o1** were fine-tuned to *think before answering*. They use structured tokens like `<think>` and `</think>` to explicitly separate the reasoning phase from the final answer.
>
> Unlike ReAct or CoT — which are prompting strategies — this is a **training-level technique**, where the model learns to think via examples.
================================================
FILE: units/en/unit1/tools.mdx
================================================
# What are Tools?
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/whiteboard-check-2.jpg" alt="Unit 1 planning"/>
One crucial aspect of AI Agents is their ability to take **actions**. As we saw, this happens through the use of **Tools**.
In this section, we’ll learn what Tools are, how to design them effectively, and how to integrate them into your Agent via the System Message.
By giving your Agent the right Tools—and clearly describing how those Tools work—you can dramatically increase what your AI can accomplish. Let’s dive in!
## What are AI Tools?
A **Tool is a function given to the LLM**. This function should fulfill a **clear objective**.
Here are some commonly used tools in AI agents:
| Tool | Description |
|----------------|---------------------------------------------------------------|
| Web Search | Allows the agent to fetch up-to-date information from the internet. |
| Image Generation | Creates images based on text descriptions. |
| Retrieval | Retrieves information from an external source. |
| API Interface | Interacts with an external API (GitHub, YouTube, Spotify, etc.). |
Those are only examples, as you can in fact create a tool for any use case!
A good tool should be something that **complements the power of an LLM**.
For instance, if you need to perform arithmetic, giving a **calculator tool** to your LLM will provide better results than relying on the native capabilities of the model.
Furthermore, **LLMs predict the completion of a prompt based on their training data**, which means that their internal knowledge only includes events prior to their training. Therefore, if your agent needs up-to-date data you must provide it through some tool.
For instance, if you ask an LLM directly (without a search tool) for today's weather, the LLM will potentially hallucinate random weather.
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/weather.jpg" alt="Weather"/>
- A Tool should contain:
- A **textual description of what the function does**.
- A *Callable* (something to perform an action).
- *Arguments* with typings.
- (Optional) Outputs with typings.
## How do tools work?
LLMs, as we saw, can only receive text inputs and generate text outputs. They have no way to call tools on their own. When we talk about providing tools to an Agent, we mean teaching the LLM about the existence of these tools and instructing it to generate text-based invocations when needed.
For example, if we provide a tool to check the weather at a location from the internet and then ask the LLM about the weather in Paris, the LLM will recognize that this is an opportunity to use the “weather” tool. Instead of retrieving the weather data itself, the LLM will generate text that represents a tool call, such as call weather_tool('Paris').
The **Agent** then reads this response, identifies that a tool call is required, executes the tool on the LLM’s behalf, and retrieves the actual weather data.
The Tool-calling steps are typically not shown to the user: the Agent appends them as a new message before passing the updated conversation to the LLM again. The LLM then processes this additional context and generates a natural-sounding response for the user. From the user’s perspective, it appears as if the LLM directly interacted with the tool, but in reality, it was the Agent that handled the entire execution process in the background.
We'll talk a lot more about this process in future sessions.
## How do we give tools to an LLM?
The complete answer may seem overwhelming, but we essentially use the system prompt to provide textual descriptions of available tools to the model:
<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/Agent_system_prompt.png" alt="System prompt for tools"/>
For this to work, we have to be very precise and accurate about:
1. **What the tool does**
2. **What exact inputs it expects**
This is the reas
gitextract_ohhcdybu/
├── .github/
│ ├── ISSUE_TEMPLATE/
│ │ ├── i-have-a-bug-with-a-hands-on.md
│ │ ├── i-have-a-question.md
│ │ └── i-want-to-improve-the-course-or-write-a-new-section.md
│ └── workflows/
│ ├── build_documentation.yml
│ ├── build_pr_documentation.yml
│ └── upload_pr_documentation.yml
├── .gitignore
├── LICENSE
├── README.md
├── quiz/
│ ├── .python-version
│ ├── README.md
│ ├── data/
│ │ └── unit_1.json
│ ├── push_questions.py
│ └── pyproject.toml
├── scripts/
│ ├── translation.py
│ └── vi.py
├── translation_agreements/
│ └── ru/
│ └── TRANSLATION_AGREEMENTS.md
└── units/
├── en/
│ ├── _toctree.yml
│ ├── bonus-unit1/
│ │ ├── conclusion.mdx
│ │ ├── fine-tuning.mdx
│ │ ├── introduction.mdx
│ │ └── what-is-function-calling.mdx
│ ├── bonus-unit2/
│ │ ├── introduction.mdx
│ │ ├── monitoring-and-evaluating-agents-notebook.mdx
│ │ ├── quiz.mdx
│ │ └── what-is-agent-observability-and-evaluation.mdx
│ ├── bonus-unit3/
│ │ ├── building_your_pokemon_agent.mdx
│ │ ├── conclusion.mdx
│ │ ├── from-llm-to-agents.mdx
│ │ ├── introduction.mdx
│ │ ├── launching_agent_battle.mdx
│ │ └── state-of-art.mdx
│ ├── communication/
│ │ └── live1.mdx
│ ├── unit0/
│ │ ├── discord101.mdx
│ │ ├── introduction.mdx
│ │ └── onboarding.mdx
│ ├── unit1/
│ │ ├── README.md
│ │ ├── actions.mdx
│ │ ├── agent-steps-and-structure.mdx
│ │ ├── conclusion.mdx
│ │ ├── dummy-agent-library.mdx
│ │ ├── final-quiz.mdx
│ │ ├── introduction.mdx
│ │ ├── messages-and-special-tokens.mdx
│ │ ├── observations.mdx
│ │ ├── quiz1.mdx
│ │ ├── quiz2.mdx
│ │ ├── thoughts.mdx
│ │ ├── tools.mdx
│ │ ├── tutorial.mdx
│ │ ├── what-are-agents.mdx
│ │ └── what-are-llms.mdx
│ ├── unit2/
│ │ ├── introduction.mdx
│ │ ├── langgraph/
│ │ │ ├── building_blocks.mdx
│ │ │ ├── conclusion.mdx
│ │ │ ├── document_analysis_agent.mdx
│ │ │ ├── first_graph.mdx
│ │ │ ├── introduction.mdx
│ │ │ ├── quiz1.mdx
│ │ │ └── when_to_use_langgraph.mdx
│ │ ├── llama-index/
│ │ │ ├── README.md
│ │ │ ├── agents.mdx
│ │ │ ├── components.mdx
│ │ │ ├── conclusion.mdx
│ │ │ ├── introduction.mdx
│ │ │ ├── llama-hub.mdx
│ │ │ ├── quiz1.mdx
│ │ │ ├── quiz2.mdx
│ │ │ ├── tools.mdx
│ │ │ └── workflows.mdx
│ │ └── smolagents/
│ │ ├── code_agents.mdx
│ │ ├── conclusion.mdx
│ │ ├── final_quiz.mdx
│ │ ├── introduction.mdx
│ │ ├── multi_agent_systems.mdx
│ │ ├── quiz1.mdx
│ │ ├── quiz2.mdx
│ │ ├── retrieval_agents.mdx
│ │ ├── tool_calling_agents.mdx
│ │ ├── tools.mdx
│ │ ├── vision_agents.mdx
│ │ └── why_use_smolagents.mdx
│ ├── unit3/
│ │ ├── README.md
│ │ └── agentic-rag/
│ │ ├── agent.mdx
│ │ ├── agentic-rag.mdx
│ │ ├── conclusion.mdx
│ │ ├── introduction.mdx
│ │ ├── invitees.mdx
│ │ └── tools.mdx
│ └── unit4/
│ ├── additional-readings.mdx
│ ├── conclusion.mdx
│ ├── get-your-certificate.mdx
│ ├── hands-on.mdx
│ ├── introduction.mdx
│ └── what-is-gaia.mdx
├── es/
│ ├── _toctree.yml
│ ├── bonus-unit1/
│ │ ├── conclusion.mdx
│ │ ├── fine-tuning.mdx
│ │ ├── introduction.mdx
│ │ └── what-is-function-calling.mdx
│ ├── bonus-unit2/
│ │ ├── introduction.mdx
│ │ ├── monitoring-and-evaluating-agents-notebook.mdx
│ │ ├── quiz.mdx
│ │ └── what-is-agent-observability-and-evaluation.mdx
│ ├── bonus-unit3/
│ │ ├── building_your_pokemon_agent.mdx
│ │ ├── conclusion.mdx
│ │ ├── from-llm-to-agents.mdx
│ │ ├── introduction.mdx
│ │ ├── launching_agent_battle.mdx
│ │ └── state-of-art.mdx
│ ├── communication/
│ │ └── live1.mdx
│ ├── unit0/
│ │ ├── discord101.mdx
│ │ ├── introduction.mdx
│ │ └── onboarding.mdx
│ ├── unit1/
│ │ ├── README.md
│ │ ├── actions.mdx
│ │ ├── agent-steps-and-structure.mdx
│ │ ├── conclusion.mdx
│ │ ├── dummy-agent-library.mdx
│ │ ├── final-quiz.mdx
│ │ ├── introduction.mdx
│ │ ├── messages-and-special-tokens.mdx
│ │ ├── observations.mdx
│ │ ├── quiz1.mdx
│ │ ├── quiz2.mdx
│ │ ├── thoughts.mdx
│ │ ├── tools.mdx
│ │ ├── tutorial.mdx
│ │ ├── what-are-agents.mdx
│ │ └── what-are-llms.mdx
│ ├── unit2/
│ │ ├── introduction.mdx
│ │ ├── langgraph/
│ │ │ ├── building_blocks.mdx
│ │ │ ├── conclusion.mdx
│ │ │ ├── document_analysis_agent.mdx
│ │ │ ├── first_graph.mdx
│ │ │ ├── introduction.mdx
│ │ │ ├── quiz1.mdx
│ │ │ └── when_to_use_langgraph.mdx
│ │ ├── llama-index/
│ │ │ ├── README.md
│ │ │ ├── agents.mdx
│ │ │ ├── components.mdx
│ │ │ ├── conclusion.mdx
│ │ │ ├── introduction.mdx
│ │ │ ├── llama-hub.mdx
│ │ │ ├── quiz1.mdx
│ │ │ ├── quiz2.mdx
│ │ │ ├── tools.mdx
│ │ │ └── workflows.mdx
│ │ └── smolagents/
│ │ ├── code_agents.mdx
│ │ ├── conclusion.mdx
│ │ ├── final_quiz.mdx
│ │ ├── introduction.mdx
│ │ ├── multi_agent_systems.mdx
│ │ ├── quiz1.mdx
│ │ ├── quiz2.mdx
│ │ ├── retrieval_agents.mdx
│ │ ├── tool_calling_agents.mdx
│ │ ├── tools.mdx
│ │ ├── vision_agents.mdx
│ │ └── why_use_smolagents.mdx
│ ├── unit3/
│ │ ├── README.md
│ │ └── agentic-rag/
│ │ ├── agent.mdx
│ │ ├── agentic-rag.mdx
│ │ ├── conclusion.mdx
│ │ ├── introduction.mdx
│ │ ├── invitees.mdx
│ │ └── tools.mdx
│ └── unit4/
│ ├── README.md
│ ├── additional-readings.mdx
│ ├── conclusion.mdx
│ ├── get-your-certificate.mdx
│ ├── hands-on.mdx
│ ├── introduction.mdx
│ └── what-is-gaia.mdx
├── fr/
│ ├── _toctree.yml
│ ├── bonus-unit1/
│ │ ├── conclusion.mdx
│ │ ├── fine-tuning.mdx
│ │ ├── introduction.mdx
│ │ └── what-is-function-calling.mdx
│ ├── bonus-unit2/
│ │ ├── introduction.mdx
│ │ ├── monitoring-and-evaluating-agents-notebook.mdx
│ │ ├── quiz.mdx
│ │ └── what-is-agent-observability-and-evaluation.mdx
│ ├── bonus-unit3/
│ │ ├── building_your_pokemon_agent.mdx
│ │ ├── conclusion.mdx
│ │ ├── from-llm-to-agents.mdx
│ │ ├── introduction.mdx
│ │ ├── launching_agent_battle.mdx
│ │ └── state-of-art.mdx
│ ├── communication/
│ │ └── live1.mdx
│ ├── unit0/
│ │ ├── discord101.mdx
│ │ ├── introduction.mdx
│ │ └── onboarding.mdx
│ ├── unit1/
│ │ ├── README.md
│ │ ├── actions.mdx
│ │ ├── agent-steps-and-structure.mdx
│ │ ├── conclusion.mdx
│ │ ├── dummy-agent-library.mdx
│ │ ├── final-quiz.mdx
│ │ ├── introduction.mdx
│ │ ├── messages-and-special-tokens.mdx
│ │ ├── observations.mdx
│ │ ├── quiz1.mdx
│ │ ├── quiz2.mdx
│ │ ├── thoughts.mdx
│ │ ├── tools.mdx
│ │ ├── tutorial.mdx
│ │ ├── what-are-agents.mdx
│ │ └── what-are-llms.mdx
│ ├── unit2/
│ │ ├── introduction.mdx
│ │ ├── langgraph/
│ │ │ ├── building_blocks.mdx
│ │ │ ├── conclusion.mdx
│ │ │ ├── document_analysis_agent.mdx
│ │ │ ├── first_graph.mdx
│ │ │ ├── introduction.mdx
│ │ │ ├── quiz1.mdx
│ │ │ └── when_to_use_langgraph.mdx
│ │ ├── llama-index/
│ │ │ ├── README.md
│ │ │ ├── agents.mdx
│ │ │ ├── components.mdx
│ │ │ ├── conclusion.mdx
│ │ │ ├── introduction.mdx
│ │ │ ├── llama-hub.mdx
│ │ │ ├── quiz1.mdx
│ │ │ ├── quiz2.mdx
│ │ │ ├── tools.mdx
│ │ │ └── workflows.mdx
│ │ └── smolagents/
│ │ ├── code_agents.mdx
│ │ ├── conclusion.mdx
│ │ ├── final_quiz.mdx
│ │ ├── introduction.mdx
│ │ ├── multi_agent_systems.mdx
│ │ ├── quiz1.mdx
│ │ ├── quiz2.mdx
│ │ ├── retrieval_agents.mdx
│ │ ├── tool_calling_agents.mdx
│ │ ├── tools.mdx
│ │ ├── vision_agents.mdx
│ │ └── why_use_smolagents.mdx
│ ├── unit3/
│ │ ├── README.md
│ │ └── agentic-rag/
│ │ ├── agent.mdx
│ │ ├── agentic-rag.mdx
│ │ ├── conclusion.mdx
│ │ ├── introduction.mdx
│ │ ├── invitees.mdx
│ │ └── tools.mdx
│ └── unit4/
│ ├── additional-readings.mdx
│ ├── conclusion.mdx
│ ├── get-your-certificate.mdx
│ ├── hands-on.mdx
│ ├── introduction.mdx
│ └── what-is-gaia.mdx
├── ko/
│ ├── _toctree.yml
│ ├── bonus-unit1/
│ │ ├── introduction.mdx
│ │ └── what-is-function-calling.mdx
│ ├── unit0/
│ │ ├── discord101.mdx
│ │ ├── introduction.mdx
│ │ └── onboarding.mdx
│ ├── unit1/
│ │ ├── README.md
│ │ ├── actions.mdx
│ │ ├── agent-steps-and-structure.mdx
│ │ ├── conclusion.mdx
│ │ ├── dummy-agent-library.mdx
│ │ ├── final-quiz.mdx
│ │ ├── introduction.mdx
│ │ ├── messages-and-special-tokens.mdx
│ │ ├── observations.mdx
│ │ ├── quiz1.mdx
│ │ ├── quiz2.mdx
│ │ ├── thoughts.mdx
│ │ ├── tools.mdx
│ │ ├── tutorial.mdx
│ │ ├── what-are-agents.mdx
│ │ └── what-are-llms.mdx
│ ├── unit2/
│ │ ├── introduction.mdx
│ │ ├── langgraph/
│ │ │ ├── building_blocks.mdx
│ │ │ ├── conclusion.mdx
│ │ │ ├── document_analysis_agent.mdx
│ │ │ ├── first_graph.mdx
│ │ │ ├── introduction.mdx
│ │ │ ├── quiz1.mdx
│ │ │ └── when_to_use_langgraph.mdx
│ │ ├── llama-index/
│ │ │ ├── README.md
│ │ │ ├── agents.mdx
│ │ │ ├── components.mdx
│ │ │ ├── conclusion.mdx
│ │ │ ├── introduction.mdx
│ │ │ ├── llama-hub.mdx
│ │ │ ├── quiz1.mdx
│ │ │ ├── quiz2.mdx
│ │ │ ├── tools.mdx
│ │ │ └── workflows.mdx
│ │ └── smolagents/
│ │ ├── code_agents.mdx
│ │ ├── conclusion.mdx
│ │ ├── final_quiz.mdx
│ │ ├── introduction.mdx
│ │ ├── multi_agent_systems.mdx
│ │ ├── quiz1.mdx
│ │ ├── quiz2.mdx
│ │ ├── retrieval_agents.mdx
│ │ ├── tool_calling_agents.mdx
│ │ ├── tools.mdx
│ │ ├── vision_agents.mdx
│ │ └── why_use_smolagents.mdx
│ └── unit4/
│ └── introduction.mdx
├── ru-RU/
│ ├── _toctree.yml
│ ├── bonus-unit1/
│ │ ├── conclusion.mdx
│ │ ├── fine-tuning.mdx
│ │ ├── introduction.mdx
│ │ └── what-is-function-calling.mdx
│ ├── communication/
│ │ ├── live1.mdx
│ │ └── next-units.mdx
│ ├── unit0/
│ │ ├── discord101.mdx
│ │ ├── introduction.mdx
│ │ └── onboarding.mdx
│ └── unit1/
│ ├── README.md
│ ├── actions.mdx
│ ├── agent-steps-and-structure.mdx
│ ├── conclusion.mdx
│ ├── dummy-agent-library.mdx
│ ├── final-quiz.mdx
│ ├── get-your-certificate.mdx
│ ├── introduction.mdx
│ ├── messages-and-special-tokens.mdx
│ ├── observations.mdx
│ ├── quiz1.mdx
│ ├── quiz2.mdx
│ ├── thoughts.mdx
│ ├── tools.mdx
│ ├── tutorial.mdx
│ ├── what-are-agents.mdx
│ └── what-are-llms.mdx
├── vi/
│ ├── _toctree.yml
│ ├── bonus-unit1/
│ │ ├── conclusion.mdx
│ │ ├── fine-tuning.mdx
│ │ ├── introduction.mdx
│ │ └── what-is-function-calling.mdx
│ ├── communication/
│ │ ├── live1.mdx
│ │ └── next-units.mdx
│ ├── unit0/
│ │ ├── discord101.mdx
│ │ ├── introduction.mdx
│ │ └── onboarding.mdx
│ ├── unit1/
│ │ ├── actions.mdx
│ │ ├── agent-steps-and-structure.mdx
│ │ ├── conclusion.mdx
│ │ ├── dummy-agent-library.mdx
│ │ ├── final-quiz.mdx
│ │ ├── introduction.mdx
│ │ ├── messages-and-special-tokens.mdx
│ │ ├── observations.mdx
│ │ ├── quiz1.mdx
│ │ ├── quiz2.mdx
│ │ ├── thoughts.mdx
│ │ ├── tools.mdx
│ │ ├── tutorial.mdx
│ │ ├── what-are-agents.mdx
│ │ └── what-are-llms.mdx
│ ├── unit2/
│ │ └── README.md
│ ├── unit3/
│ │ └── README.md
│ └── unit4/
│ └── README.md
└── zh-CN/
├── _toctree.yml
├── bonus-unit1/
│ ├── conclusion.mdx
│ ├── fine-tuning.mdx
│ ├── introduction.mdx
│ └── what-is-function-calling.mdx
├── bonus-unit3/
│ ├── building_your_pokemon_agent.mdx
│ ├── conclusion.mdx
│ ├── from-llm-to-agents.mdx
│ ├── introduction.mdx
│ ├── launching_agent_battle.mdx
│ └── state-of-art.mdx
├── bonus_unit2/
│ ├── introduction.mdx
│ ├── monitoring-and-evaluating-agents-notebook.mdx
│ ├── quiz.mdx
│ └── what-is-agent-observability-and-evaluation.mdx
├── communication/
│ ├── live1.mdx
│ └── next-units.mdx
├── unit0/
│ ├── discord101.mdx
│ ├── introduction.mdx
│ └── onboarding.mdx
├── unit1/
│ ├── README.md
│ ├── actions.mdx
│ ├── agent-steps-and-structure.mdx
│ ├── conclusion.mdx
│ ├── dummy-agent-library.mdx
│ ├── final-quiz.mdx
│ ├── introduction.mdx
│ ├── messages-and-special-tokens.mdx
│ ├── observations.mdx
│ ├── quiz1.mdx
│ ├── quiz2.mdx
│ ├── thoughts.mdx
│ ├── tools.mdx
│ ├── tutorial.mdx
│ ├── what-are-agents.mdx
│ └── what-are-llms.mdx
├── unit2/
│ ├── introduction.mdx
│ ├── langgraph/
│ │ ├── building_blocks.mdx
│ │ ├── conclusion.mdx
│ │ ├── document_analysis_agent.mdx
│ │ ├── first_graph.mdx
│ │ ├── introduction.mdx
│ │ ├── quiz1.mdx
│ │ └── when_to_use_langgraph.mdx
│ ├── llama-index/
│ │ ├── README.md
│ │ ├── agents.mdx
│ │ ├── components.mdx
│ │ ├── conclusion.mdx
│ │ ├── introduction.mdx
│ │ ├── llama-hub.mdx
│ │ ├── quiz1.mdx
│ │ ├── quiz2.mdx
│ │ ├── tools.mdx
│ │ └── workflows.mdx
│ └── smolagents/
│ ├── code_agents.mdx
│ ├── conclusion.mdx
│ ├── final_quiz.mdx
│ ├── introduction.mdx
│ ├── multi_agent_systems.mdx
│ ├── quiz1.mdx
│ ├── quiz2.mdx
│ ├── retrieval_agents.mdx
│ ├── tool_calling_agents.mdx
│ ├── tools.mdx
│ ├── vision_agents.mdx
│ └── why_use_smolagents.mdx
├── unit3/
│ ├── README.md
│ └── agentic-rag/
│ ├── agent.mdx
│ ├── agentic-rag.mdx
│ ├── conclusion.mdx
│ ├── introduction.mdx
│ ├── invitees.mdx
│ └── tools.mdx
└── unit4/
├── additional-readings.mdx
├── conclusion.mdx
├── get-your-certificate.mdx
├── hands-on.mdx
├── introduction.mdx
└── what-is-gaia.mdx
SYMBOL INDEX (2 symbols across 2 files) FILE: quiz/push_questions.py function main (line 10) | def main(): FILE: scripts/translation.py function auto_translate (line 15) | def auto_translate(
Condensed preview — 439 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (2,397K chars).
[
{
"path": ".github/ISSUE_TEMPLATE/i-have-a-bug-with-a-hands-on.md",
"chars": 496,
"preview": "---\nname: I have a bug with a hands-on\nabout: You have encountered a bug during one of the hands-on\ntitle: \"[HANDS-ON BU"
},
{
"path": ".github/ISSUE_TEMPLATE/i-have-a-question.md",
"chars": 333,
"preview": "---\nname: I have a question\nabout: You have a question about a section of the course\ntitle: \"[QUESTION]\"\nlabels: questio"
},
{
"path": ".github/ISSUE_TEMPLATE/i-want-to-improve-the-course-or-write-a-new-section.md",
"chars": 508,
"preview": "---\nname: I want to improve the course or write a new section\nabout: You found a typo, an error or you want to improve a"
},
{
"path": ".github/workflows/build_documentation.yml",
"chars": 467,
"preview": "name: Build documentation\n\non:\n push:\n branches:\n - main\n\njobs:\n build:\n uses: huggingface/doc-builder/.git"
},
{
"path": ".github/workflows/build_pr_documentation.yml",
"chars": 568,
"preview": "name: Build PR Documentation\n\non:\n pull_request:\n\nconcurrency:\n group: ${{ github.workflow }}-${{ github.head_ref || g"
},
{
"path": ".github/workflows/upload_pr_documentation.yml",
"chars": 544,
"preview": "name: Upload PR Documentation\n\non:\n workflow_run:\n workflows: [\"Build PR Documentation\"]\n types:\n - complete"
},
{
"path": ".gitignore",
"chars": 3551,
"preview": "# Byte-compiled / optimized / DLL files\n__pycache__/\n*.py[cod]\n*$py.class\n\n# C extensions\n*.so\n\n# Distribution / packagi"
},
{
"path": "LICENSE",
"chars": 11357,
"preview": " Apache License\n Version 2.0, January 2004\n "
},
{
"path": "README.md",
"chars": 5276,
"preview": "# <a href=\"https://hf.co/learn/agents-course\" target=\"_blank\">The Hugging Face Agents Course</a>\n\nIf you like the course"
},
{
"path": "quiz/.python-version",
"chars": 5,
"preview": "3.11\n"
},
{
"path": "quiz/README.md",
"chars": 27,
"preview": "# Agent Course quiz scripts"
},
{
"path": "quiz/data/unit_1.json",
"chars": 474,
"preview": "[\n {\n \"question\": \"Which of the following best describes a Large Language Model (LLM)?\",\n \"answer_a\": \""
},
{
"path": "quiz/push_questions.py",
"chars": 707,
"preview": "import json\nfrom pathlib import Path\nfrom datasets import Dataset\nfrom huggingface_hub import HfApi\n\n\nORG_NAME = \"agents"
},
{
"path": "quiz/pyproject.toml",
"chars": 263,
"preview": "[project]\nname = \"agents-course\"\nversion = \"0.1.0\"\ndescription = \"Add your description here\"\nreadme = \"README.md\"\nrequir"
},
{
"path": "scripts/translation.py",
"chars": 3051,
"preview": "import os\nimport sys\nimport re\nfrom huggingface_hub import InferenceClient\n\n# Get the directory containing the current s"
},
{
"path": "scripts/vi.py",
"chars": 4104,
"preview": "from translation import auto_translate\n\noutput_lang = \"vi\"\n\nprompt = lambda content: f'''\nYou are a translator for the V"
},
{
"path": "translation_agreements/ru/TRANSLATION_AGREEMENTS.md",
"chars": 6170,
"preview": "## Об организации процесса перевода в команде:\n\n0. У нас Холакратия. Координатор команды - не менеджер! Он координирует "
},
{
"path": "units/en/_toctree.yml",
"chars": 6160,
"preview": "- title: Unit 0. Welcome to the course\n sections:\n - local: unit0/introduction\n title: Welcome to the course 🤗\n - "
},
{
"path": "units/en/bonus-unit1/conclusion.mdx",
"chars": 751,
"preview": "# Conclusion [[conclusion]]\n\nCongratulations on finishing this first Bonus Unit 🥳\n\nYou've just **mastered understanding "
},
{
"path": "units/en/bonus-unit1/fine-tuning.mdx",
"chars": 3842,
"preview": "# Let's Fine-Tune Your Model for Function-Calling\n\nWe're now ready to fine-tune our first model for function-calling 🔥.\n"
},
{
"path": "units/en/bonus-unit1/introduction.mdx",
"chars": 2818,
"preview": "# Introduction\n\n![Bonus Unit 1 Thumbnail](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/bo"
},
{
"path": "units/en/bonus-unit1/what-is-function-calling.mdx",
"chars": 3607,
"preview": "# What is Function Calling?\n\nFunction-calling is a **way for an LLM to take actions on its environment**. It was first ["
},
{
"path": "units/en/bonus-unit2/introduction.mdx",
"chars": 1711,
"preview": "# AI Agent Observability & Evaluation\n\n![Bonus Unit 2 Thumbnail](https://langfuse.com/images/cookbook/huggingface-agent-"
},
{
"path": "units/en/bonus-unit2/monitoring-and-evaluating-agents-notebook.mdx",
"chars": 17630,
"preview": "<CourseFloatingBanner chapter={2}\n classNames=\"absolute z-10 right-0 top-0\"\n notebooks={[\n {label: \"Google Colab\", "
},
{
"path": "units/en/bonus-unit2/quiz.mdx",
"chars": 4993,
"preview": "# Quiz: Evaluating AI Agents\n\nLet's assess your understanding of the agent tracing and evaluation concepts covered in th"
},
{
"path": "units/en/bonus-unit2/what-is-agent-observability-and-evaluation.mdx",
"chars": 9907,
"preview": "# AI Agent Observability and Evaluation\n\n## 🔎 What is Observability?\n\nObservability is about understanding what's happen"
},
{
"path": "units/en/bonus-unit3/building_your_pokemon_agent.mdx",
"chars": 12460,
"preview": "# Build Your Own Pokémon Battle Agent\n\nNow that you’ve explored the potential and limitations of Agentic AI in games, it"
},
{
"path": "units/en/bonus-unit3/conclusion.mdx",
"chars": 983,
"preview": "# Conclusion\n\nIf you've made it this far, congratulations! 🥳 You've successfully built your very own Pokémon battle agen"
},
{
"path": "units/en/bonus-unit3/from-llm-to-agents.mdx",
"chars": 2715,
"preview": "# From LLMs to AI Agents\n\nWe learned in the [first unit](https://huggingface.co/learn/agents-course/unit1/introduction) "
},
{
"path": "units/en/bonus-unit3/introduction.mdx",
"chars": 1828,
"preview": "# Introduction\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/bonus-unit3/pokemo"
},
{
"path": "units/en/bonus-unit3/launching_agent_battle.mdx",
"chars": 2850,
"preview": "# Launching Your Pokémon Battle Agent\n\nIt's now time to battle! ⚡️\n\n## **Battle the Stream Agent!**\n\nIf you don't feel l"
},
{
"path": "units/en/bonus-unit3/state-of-art.mdx",
"chars": 3009,
"preview": "# The State of the Art in Using LLMs in Games\n\nTo give you a sense of how much progress has been made in this field, let"
},
{
"path": "units/en/communication/live1.mdx",
"chars": 712,
"preview": "# Live 1: How the Course Works and First Q&A\n\nIn this first live stream of the Agents Course, we explained how the cours"
},
{
"path": "units/en/unit0/discord101.mdx",
"chars": 2751,
"preview": "# (Optional) Discord 101 [[discord-101]]\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-images/resolve/"
},
{
"path": "units/en/unit0/introduction.mdx",
"chars": 9464,
"preview": "# Welcome to the 🤗 AI Agents Course [[introduction]]\n\n<figure>\n<img src=\"https://huggingface.co/datasets/agents-course/c"
},
{
"path": "units/en/unit0/onboarding.mdx",
"chars": 4333,
"preview": "# Onboarding: Your First Steps ⛵\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/"
},
{
"path": "units/en/unit1/README.md",
"chars": 1470,
"preview": "# Table of Contents\n\nYou can access Unit 1 on hf.co/learn 👉 <a href=\"https://hf.co/learn/agents-course/unit1/introductio"
},
{
"path": "units/en/unit1/actions.mdx",
"chars": 6906,
"preview": "# Actions: Enabling the Agent to Engage with Its Environment\n\n> [!TIP]\n> In this section, we explore the concrete steps"
},
{
"path": "units/en/unit1/agent-steps-and-structure.mdx",
"chars": 6438,
"preview": "# Understanding AI Agents through the Thought-Action-Observation Cycle\n\n<img src=\"https://huggingface.co/datasets/agents"
},
{
"path": "units/en/unit1/conclusion.mdx",
"chars": 1222,
"preview": "# Conclusion [[conclusion]]\n\nCongratulations on finishing this first Unit 🥳\n\nYou've just **mastered the fundamentals of "
},
{
"path": "units/en/unit1/dummy-agent-library.mdx",
"chars": 11117,
"preview": "# Dummy Agent Library\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/white"
},
{
"path": "units/en/unit1/final-quiz.mdx",
"chars": 1663,
"preview": "# Unit 1 Quiz\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/whiteboard-un"
},
{
"path": "units/en/unit1/introduction.mdx",
"chars": 1834,
"preview": "# Introduction to Agents\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/th"
},
{
"path": "units/en/unit1/messages-and-special-tokens.mdx",
"chars": 10982,
"preview": "# Messages and Special Tokens\n\nNow that we understand how LLMs work, let's look at **how they structure their generation"
},
{
"path": "units/en/unit1/observations.mdx",
"chars": 2619,
"preview": "# Observe: Integrating Feedback to Reflect and Adapt\n\nObservations are **how an Agent perceives the consequences of its "
},
{
"path": "units/en/unit1/quiz1.mdx",
"chars": 6813,
"preview": "### Q1: What is an Agent?\nWhich of the following best describes an AI Agent?\n\n<Question\nchoices={[\n{\ntext: \"An AI model "
},
{
"path": "units/en/unit1/quiz2.mdx",
"chars": 2767,
"preview": "# Quick Self-Check (ungraded) [[quiz2]] \n\n\nWhat?! Another Quiz? We know, we know, ... 😅 But this short, ungraded quiz is"
},
{
"path": "units/en/unit1/thoughts.mdx",
"chars": 4710,
"preview": "\n# Thought: Internal Reasoning and the ReAct Approach\n\n> [!TIP]\n> In this section, we dive into the inner workings of an"
},
{
"path": "units/en/unit1/tools.mdx",
"chars": 14015,
"preview": "# What are Tools?\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/whiteboar"
},
{
"path": "units/en/unit1/tutorial.mdx",
"chars": 10519,
"preview": "# Let's Create Our First Agent Using smolagents\n\nIn the last section, we learned how we can create Agents from scratch u"
},
{
"path": "units/en/unit1/what-are-agents.mdx",
"chars": 8634,
"preview": "# What is an Agent?\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/whitebo"
},
{
"path": "units/en/unit1/what-are-llms.mdx",
"chars": 12308,
"preview": "# What are LLMs?\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/whiteboard"
},
{
"path": "units/en/unit2/introduction.mdx",
"chars": 2658,
"preview": "# Introduction to Agentic Frameworks\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-images/resolve/main"
},
{
"path": "units/en/unit2/langgraph/building_blocks.mdx",
"chars": 3806,
"preview": "# Building Blocks of LangGraph\n\nTo build applications with LangGraph, you need to understand its core components. Let's "
},
{
"path": "units/en/unit2/langgraph/conclusion.mdx",
"chars": 1020,
"preview": "# Conclusion\n\nCongratulations on finishing the `LangGraph` module of this second Unit! 🥳\n\nYou've now mastered the fundam"
},
{
"path": "units/en/unit2/langgraph/document_analysis_agent.mdx",
"chars": 9363,
"preview": "# Document Analysis Graph\n\nAlfred at your service. As Mr. Wayne's trusted butler, I've taken the liberty of documenting "
},
{
"path": "units/en/unit2/langgraph/first_graph.mdx",
"chars": 13313,
"preview": "# Building Your First LangGraph\n\nNow that we understand the building blocks, let's put them into practice by building ou"
},
{
"path": "units/en/unit2/langgraph/introduction.mdx",
"chars": 1668,
"preview": "# Introduction to `LangGraph`\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/uni"
},
{
"path": "units/en/unit2/langgraph/quiz1.mdx",
"chars": 4601,
"preview": "# Test Your Understanding of LangGraph\n\nLet's test your understanding of `LangGraph` with a quick quiz! This will help r"
},
{
"path": "units/en/unit2/langgraph/when_to_use_langgraph.mdx",
"chars": 4336,
"preview": "# What is `LangGraph`? [[what-is-langgraph]]\n\n`LangGraph` is a framework developed by [LangChain](https://www.langchain."
},
{
"path": "units/en/unit2/llama-index/README.md",
"chars": 864,
"preview": "# Table of Contents\n\nThis LlamaIndex frame outline is part of unit 2 of the course. You can access the unit 2 about Llam"
},
{
"path": "units/en/unit2/llama-index/agents.mdx",
"chars": 7417,
"preview": "# Using Agents in LlamaIndex\n\nRemember Alfred, our helpful butler agent from earlier? Well, he's about to get an upgrade"
},
{
"path": "units/en/unit2/llama-index/components.mdx",
"chars": 12768,
"preview": "# What are components in LlamaIndex?\n\nRemember Alfred, our helpful butler agent from Unit 1?\nTo assist us effectively, A"
},
{
"path": "units/en/unit2/llama-index/conclusion.mdx",
"chars": 725,
"preview": "# Conclusion\n\nCongratulations on finishing the `llama-index` module of this second Unit 🥳\n\nYou’ve just mastered the fund"
},
{
"path": "units/en/unit2/llama-index/introduction.mdx",
"chars": 2629,
"preview": "# Introduction to LlamaIndex\n\nWelcome to this module, where you’ll learn how to build LLM-powered agents using the [Llam"
},
{
"path": "units/en/unit2/llama-index/llama-hub.mdx",
"chars": 2025,
"preview": "# Introduction to the LlamaHub\n\n**LlamaHub is a registry of hundreds of integrations, agents and tools that you can use "
},
{
"path": "units/en/unit2/llama-index/quiz1.mdx",
"chars": 3645,
"preview": "# Small Quiz (ungraded) [[quiz1]]\n\nSo far we've discussed the key components and tools used in LlamaIndex.\nIt's time to "
},
{
"path": "units/en/unit2/llama-index/quiz2.mdx",
"chars": 2822,
"preview": "# Quick Self-Check (ungraded) [[quiz2]]\n\nWhat?! Another Quiz? We know, we know, ... 😅 But this short, ungraded quiz is h"
},
{
"path": "units/en/unit2/llama-index/tools.mdx",
"chars": 7291,
"preview": "# Using Tools in LlamaIndex\n\n**Defining a clear set of Tools is crucial to performance.** As we discussed in [unit 1](.."
},
{
"path": "units/en/unit2/llama-index/workflows.mdx",
"chars": 9827,
"preview": "# Creating agentic workflows in LlamaIndex\n\nA workflow in LlamaIndex provides a structured way to organize your code int"
},
{
"path": "units/en/unit2/smolagents/code_agents.mdx",
"chars": 20149,
"preview": "<CourseFloatingBanner\n classNames=\"absolute z-10 right-0 top-0\"\n notebooks={[\n {label: \"Google Colab\", value: \"http"
},
{
"path": "units/en/unit2/smolagents/conclusion.mdx",
"chars": 686,
"preview": "# Conclusion\n\nCongratulations on finishing the `smolagents` module of this second Unit 🥳\n\nYou’ve just mastered the funda"
},
{
"path": "units/en/unit2/smolagents/final_quiz.mdx",
"chars": 966,
"preview": "# Exam Time!\n\nWell done on working through the material on `smolagents`! You've already achieved a lot. Now, it's time t"
},
{
"path": "units/en/unit2/smolagents/introduction.mdx",
"chars": 6472,
"preview": "# Introduction to `smolagents`\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/un"
},
{
"path": "units/en/unit2/smolagents/multi_agent_systems.mdx",
"chars": 20442,
"preview": "<CourseFloatingBanner \n classNames=\"absolute z-10 right-0 top-0\"\n notebooks={[\n {label: \"Google Colab\", value: \"htt"
},
{
"path": "units/en/unit2/smolagents/quiz1.mdx",
"chars": 6252,
"preview": "# Small Quiz (ungraded) [[quiz1]]\n\nLet's test your understanding of `smolagents` with a quick quiz! Remember, testing yo"
},
{
"path": "units/en/unit2/smolagents/quiz2.mdx",
"chars": 6613,
"preview": "# Small Quiz (ungraded) [[quiz2]]\n\nIt's time to test your understanding of the *Code Agents*, *Tool Calling Agents*, and"
},
{
"path": "units/en/unit2/smolagents/retrieval_agents.mdx",
"chars": 9164,
"preview": "<CourseFloatingBanner \n classNames=\"absolute z-10 right-0 top-0\"\n notebooks={[\n {label: \"Google Colab\", value: \"htt"
},
{
"path": "units/en/unit2/smolagents/tool_calling_agents.mdx",
"chars": 4052,
"preview": "<CourseFloatingBanner \n classNames=\"absolute z-10 right-0 top-0\"\n notebooks={[\n {label: \"Google Colab\", value: \"htt"
},
{
"path": "units/en/unit2/smolagents/tools.mdx",
"chars": 14865,
"preview": "<CourseFloatingBanner \n classNames=\"absolute z-10 right-0 top-0\"\n notebooks={[\n {label: \"Google Colab\", value: \"htt"
},
{
"path": "units/en/unit2/smolagents/vision_agents.mdx",
"chars": 12703,
"preview": "<CourseFloatingBanner \n classNames=\"absolute z-10 right-0 top-0\"\n notebooks={[\n {label: \"Google Colab\", value: \"htt"
},
{
"path": "units/en/unit2/smolagents/why_use_smolagents.mdx",
"chars": 5078,
"preview": "![smolagents banner](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/smolagents/license_to"
},
{
"path": "units/en/unit3/README.md",
"chars": 0,
"preview": ""
},
{
"path": "units/en/unit3/agentic-rag/agent.mdx",
"chars": 18029,
"preview": "# Creating Your Gala Agent\n\nNow that we've built all the necessary components for Alfred, it's time to bring everything "
},
{
"path": "units/en/unit3/agentic-rag/agentic-rag.mdx",
"chars": 1853,
"preview": "# Agentic Retrieval Augmented Generation (RAG)\n\nIn this unit, we'll be taking a look at how we can use Agentic RAG to he"
},
{
"path": "units/en/unit3/agentic-rag/conclusion.mdx",
"chars": 1062,
"preview": "# Conclusion\n\nIn this unit, we've learned how to create an agentic RAG system to help Alfred, our friendly neighborhood "
},
{
"path": "units/en/unit3/agentic-rag/introduction.mdx",
"chars": 2975,
"preview": "# Introduction to Use Case for Agentic RAG\n\n![Agentic RAG banner](https://huggingface.co/datasets/agents-course/course-i"
},
{
"path": "units/en/unit3/agentic-rag/invitees.mdx",
"chars": 17429,
"preview": "# Creating a RAG Tool for Guest Stories\n\n\nAlfred, your trusted agent, is preparing for the most extravagant gala of the "
},
{
"path": "units/en/unit3/agentic-rag/tools.mdx",
"chars": 13604,
"preview": "# Building and Integrating Tools for Your Agent\n\nIn this section, we'll grant Alfred access to the web, enabling him to "
},
{
"path": "units/en/unit4/additional-readings.mdx",
"chars": 1640,
"preview": "# And now? What topics I should learn?\n\nAgentic AI is a rapidly evolving field, and understanding foundational protocols"
},
{
"path": "units/en/unit4/conclusion.mdx",
"chars": 575,
"preview": "# Conclusion\n\n**Congratulations on finishing the Agents Course!** \n\nThrough perseverance and dedication, you’ve built a "
},
{
"path": "units/en/unit4/get-your-certificate.mdx",
"chars": 1107,
"preview": "# Claim Your Certificate 🎓\n\nIf you scored **above 30%, congratulations! 👏 You're now eligible to claim your official cer"
},
{
"path": "units/en/unit4/hands-on.mdx",
"chars": 3488,
"preview": "# Hands-On\n\nNow that you’re ready to dive deeper into the creation of your final agent, let’s see how you can submit it "
},
{
"path": "units/en/unit4/introduction.mdx",
"chars": 1653,
"preview": "# Welcome to the final Unit [[introduction]]\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-images/reso"
},
{
"path": "units/en/unit4/what-is-gaia.mdx",
"chars": 3877,
"preview": "# What is GAIA?\n\n[GAIA](https://huggingface.co/papers/2311.12983) is a **benchmark designed to evaluate AI assistants on"
},
{
"path": "units/es/_toctree.yml",
"chars": 6392,
"preview": "- title: Unit 0. Bienvenida al curso\n sections:\n - local: unit0/introduction\n title: Bienvenida al curso 🤗\n - loca"
},
{
"path": "units/es/bonus-unit1/conclusion.mdx",
"chars": 798,
"preview": "# Conclusión [[conclusion]]\n\n¡Felicidades por terminar esta primera Unidad Bonus 🥳\n\n¡Acabas de **dominar la comprensión "
},
{
"path": "units/es/bonus-unit1/fine-tuning.mdx",
"chars": 4277,
"preview": "# Hagamos Fine-Tuning de Tu Modelo para Llamadas a Funciones\n\nAhora estamos listos para hacer fine-tuning de nuestro pri"
},
{
"path": "units/es/bonus-unit1/introduction.mdx",
"chars": 3218,
"preview": "# Introducción\n\n![Bonus Unit 1 Thumbnail](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/bo"
},
{
"path": "units/es/bonus-unit1/what-is-function-calling.mdx",
"chars": 3901,
"preview": "# ¿Qué es la Llamada a Funciones?\n\nLa llamada a funciones es una **forma para que un LLM realice acciones en su entorno*"
},
{
"path": "units/es/bonus-unit2/introduction.mdx",
"chars": 1989,
"preview": "# Observabilidad y Evaluación de Agentes de IA\n\n![Bonus Unit 2 Thumbnail](https://langfuse.com/images/cookbook/huggingfa"
},
{
"path": "units/es/bonus-unit2/monitoring-and-evaluating-agents-notebook.mdx",
"chars": 19734,
"preview": "<CourseFloatingBanner chapter={2}\n classNames=\"absolute z-10 right-0 top-0\"\n notebooks={[\n {label: \"Google Colab\", "
},
{
"path": "units/es/bonus-unit2/quiz.mdx",
"chars": 5775,
"preview": "# Cuestionario: Evaluación de Agentes de IA\n\nVamos a evaluar tu comprensión de los conceptos de rastreo y evaluación de "
},
{
"path": "units/es/bonus-unit2/what-is-agent-observability-and-evaluation.mdx",
"chars": 11905,
"preview": "# Observabilidad y Evaluación de Agentes de IA\n\n## 🔎 ¿Qué es la Observabilidad?\n\nLa observabilidad consiste en entender "
},
{
"path": "units/es/bonus-unit3/building_your_pokemon_agent.mdx",
"chars": 13125,
"preview": "# Construye tu Propio Agente de Batalla Pokémon\n\nAhora que has explorado el potencial y las limitaciones de la IA Agénti"
},
{
"path": "units/es/bonus-unit3/conclusion.mdx",
"chars": 1062,
"preview": "# Conclusión\n\nSi llegaste hasta aquí, ¡felicidades! 🥳 ¡Has construido con éxito tu propio agente de batalla Pokémon! ⚔️🎮"
},
{
"path": "units/es/bonus-unit3/from-llm-to-agents.mdx",
"chars": 3083,
"preview": "# De LLMs a Agentes de IA\n\nAprendimos en la [primera unidad](https://huggingface.co/learn/agents-course/unit1/introducti"
},
{
"path": "units/es/bonus-unit3/introduction.mdx",
"chars": 1987,
"preview": "# Introducción\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/bonus-unit3/pokemo"
},
{
"path": "units/es/bonus-unit3/launching_agent_battle.mdx",
"chars": 3110,
"preview": "# Lanzando tu Agente de Batalla Pokémon\n\n¡Es hora de luchar! ⚡️\n\n## **¡Lucha contra el Agente del Stream!**\n\nSi no tiene"
},
{
"path": "units/es/bonus-unit3/state-of-art.mdx",
"chars": 3201,
"preview": "# El Estado del Arte en el Uso de LLMs en Juegos\n\nPara darte una idea de cuánto se ha avanzado en este campo, examinemos"
},
{
"path": "units/es/communication/live1.mdx",
"chars": 770,
"preview": "# Live 1: Como funciona el curso y preguntas y respuestas\n\nEn esta primera sesión en vivo del Curso de Agentes, explicam"
},
{
"path": "units/es/unit0/discord101.mdx",
"chars": 2993,
"preview": "# (Opcional) Discord 101 [[discord-101]]\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-images/resolve/"
},
{
"path": "units/es/unit0/introduction.mdx",
"chars": 10989,
"preview": "# Bienvenido/a al curso de 🤗 Agentes IA [[introduction]]\n\n<figure>\n<img src=\"https://huggingface.co/datasets/agents-cou"
},
{
"path": "units/es/unit0/onboarding.mdx",
"chars": 2666,
"preview": "# Incorporación: Tus Primeros Pasos ⛵\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-images/resolve/mai"
},
{
"path": "units/es/unit1/README.md",
"chars": 1674,
"preview": "# Tabla de Contenidos\n\nPuedes acceder a la Unidad 1 en hf.co/learn 👉 <a href=\"https://hf.co/learn/agents-course/unit1/in"
},
{
"path": "units/es/unit1/actions.mdx",
"chars": 6984,
"preview": "# Acciones: Permitiendo al Agente Interactuar con Su Entorno\n\n> [!TIP]\n> En esta sección, exploramos los pasos concretos"
},
{
"path": "units/es/unit1/agent-steps-and-structure.mdx",
"chars": 7059,
"preview": "# Entendiendo los Agentes de IA a través del Ciclo Pensamiento-Acción-Observación\n\n<img src=\"https://huggingface.co/data"
},
{
"path": "units/es/unit1/conclusion.mdx",
"chars": 1311,
"preview": "# Conclusión [[conclusion]]\n\n¡Felicitaciones por terminar esta primera Unidad 🥳\n\n¡Acabas de **dominar los fundamentos de"
},
{
"path": "units/es/unit1/dummy-agent-library.mdx",
"chars": 12619,
"preview": "# Biblioteca de Agente de Prueba\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/"
},
{
"path": "units/es/unit1/final-quiz.mdx",
"chars": 1750,
"preview": "# Quiz de la Unidad 1\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/white"
},
{
"path": "units/es/unit1/introduction.mdx",
"chars": 1992,
"preview": "# Introducción a los Agentes\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit"
},
{
"path": "units/es/unit1/messages-and-special-tokens.mdx",
"chars": 12006,
"preview": "# Mensajes y Tokens especiales\n\nAhora que entendemos cómo funcionan los LLMs, veamos **cómo estructuran sus generaciones"
},
{
"path": "units/es/unit1/observations.mdx",
"chars": 2999,
"preview": "# Observar: Integrando Retroalimentación para Reflexionar y Adaptarse\n\nLas observaciones son **cómo un Agente percibe la"
},
{
"path": "units/es/unit1/quiz1.mdx",
"chars": 7947,
"preview": "### P1: ¿Qué es un Agente?\n¿Cuál de las siguientes opciones describe mejor a un Agente de IA?\n\n<Question\nchoices={[\n{\nte"
},
{
"path": "units/es/unit1/quiz2.mdx",
"chars": 3161,
"preview": "# Autoevaluación Rápida (sin calificación) [[quiz2]] \n\n\n¡¿Qué?! ¿Otro Quiz? Lo sabemos, lo sabemos, ... 😅 Pero este brev"
},
{
"path": "units/es/unit1/thoughts.mdx",
"chars": 4169,
"preview": "# Pensamiento: Razonamiento Interno y el Enfoque Re-Act\n\n> [!TIP]\n> En esta sección, profundizamos en el funcionamiento "
},
{
"path": "units/es/unit1/tools.mdx",
"chars": 14804,
"preview": "# ¿Qué son las Herramientas?\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit"
},
{
"path": "units/es/unit1/tutorial.mdx",
"chars": 10022,
"preview": "# Vamos Crear Nuestro Primer Agente Usando smolagents\n\nEn la última sección, aprendimos cómo podemos crear Agentes desde"
},
{
"path": "units/es/unit1/what-are-agents.mdx",
"chars": 8554,
"preview": "# ¿Qué es un Agente?\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/whiteb"
},
{
"path": "units/es/unit1/what-are-llms.mdx",
"chars": 13350,
"preview": "# ¿Qué son los LLMs?\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/whiteb"
},
{
"path": "units/es/unit2/introduction.mdx",
"chars": 2414,
"preview": "# Introducción a los Frameworks de Agentes\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-images/resolv"
},
{
"path": "units/es/unit2/langgraph/building_blocks.mdx",
"chars": 4159,
"preview": "# Componentes de LangGraph\n\nPara crear aplicaciones con LangGraph necesitas conocer sus elementos principales. Exploremo"
},
{
"path": "units/es/unit2/langgraph/conclusion.mdx",
"chars": 1032,
"preview": "# Conclusión\n\n¡Felicidades por terminar el módulo de `LangGraph` de esta segunda Unidad! 🥳\n\nAhora has dominado los funda"
},
{
"path": "units/es/unit2/langgraph/document_analysis_agent.mdx",
"chars": 9440,
"preview": "# Grafo de Análisis de Documentos\n\nAlfred a su servicio. Como mayordomo de confianza del Sr. Wayne, me he tomado la libe"
},
{
"path": "units/es/unit2/langgraph/first_graph.mdx",
"chars": 14073,
"preview": "# Construyendo Tu Primer LangGraph\n\nAhora que entendemos los componentes básicos, vamos a ponerlos en práctica construye"
},
{
"path": "units/es/unit2/langgraph/introduction.mdx",
"chars": 1781,
"preview": "# Introducción a `LangGraph`\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit"
},
{
"path": "units/es/unit2/langgraph/quiz1.mdx",
"chars": 5373,
"preview": "# Evalua de tu comprensión de LangGraph\n\n¡Vamos a comprobar tu comprensión de `LangGraph` on un breve cuestionario! Esto"
},
{
"path": "units/es/unit2/langgraph/when_to_use_langgraph.mdx",
"chars": 4802,
"preview": "# ¿Qué es `LangGraph`?\n\n`LangGraph` s un marco de trabajo desarrollado por [LangChain](https://www.langchain.com/) **par"
},
{
"path": "units/es/unit2/llama-index/README.md",
"chars": 980,
"preview": "# Índice de Contenidos\n\nEste marco de trabajo de LlamaIndex es parte de la unidad 2 del curso. Puedes acceder a la unida"
},
{
"path": "units/es/unit2/llama-index/agents.mdx",
"chars": 8431,
"preview": "# Usando Agentes en LlamaIndex\n\n¿Recuerdas a Alfred, nuestro agente mayordomo útil de antes? ¡Bueno, está a punto de rec"
},
{
"path": "units/es/unit2/llama-index/components.mdx",
"chars": 13865,
"preview": "# ¿Qué son los componentes en LlamaIndex?\n\n¿Recuerdas a Alfred, nuestro útil agente mayordomo de la Unidad 1? \nPara ayud"
},
{
"path": "units/es/unit2/llama-index/conclusion.mdx",
"chars": 860,
"preview": "# Conclusión\n\n!Felicidades por terminar el módulo `llama-index` de esta segunda Unidad 🥳\n\nAcabas de dominar los fundamen"
},
{
"path": "units/es/unit2/llama-index/introduction.mdx",
"chars": 2999,
"preview": "# Introducción a LlamaIndex\n\nBienvenido a este módulo, donde aprenderás a construir agentes impulsados por LLM utilizand"
},
{
"path": "units/es/unit2/llama-index/llama-hub.mdx",
"chars": 1886,
"preview": "# Introducción a LlamaHub\n\n**LlamaHub es un registro de cientos de integraciones, agentes y herramientas que puedes util"
},
{
"path": "units/es/unit2/llama-index/quiz1.mdx",
"chars": 4139,
"preview": "# Pequeño Quiz (no calificado) [[quiz1]]\n\nHasta ahora hemos discutido los componentes clave y herramientas utilizadas en"
},
{
"path": "units/es/unit2/llama-index/quiz2.mdx",
"chars": 3170,
"preview": "# Autoevaluación Rápida (sin calificar) [[quiz2]]\n\n¿Qué?! Otra autoevaluación? Lo sabemos, lo sabemos, ... 😅 Pero esta b"
},
{
"path": "units/es/unit2/llama-index/tools.mdx",
"chars": 7167,
"preview": "# Uso de Herramientas en LlamaIndex\n\n**Definir un conjunto claro de herramientas es crucial para el rendimiento.** Como "
},
{
"path": "units/es/unit2/llama-index/workflows.mdx",
"chars": 10425,
"preview": "# Crear workflows agenticos en LlamaIndex\n\nUn workflow en LlamaIndex proporciona una forma estructurada de organizar su "
},
{
"path": "units/es/unit2/smolagents/code_agents.mdx",
"chars": 20607,
"preview": "<CourseFloatingBanner chapter={2}\n classNames=\"absolute z-10 right-0 top-0\"\n notebooks={[\n {label: \"Google Colab\", "
},
{
"path": "units/es/unit2/smolagents/conclusion.mdx",
"chars": 696,
"preview": "# Conclusión\n\n¡Felicitaciones por terminar el módulo de `smolagents` de esta segunda Unidad 🥳\n\n¡Acabas de dominar los fu"
},
{
"path": "units/es/unit2/smolagents/final_quiz.mdx",
"chars": 1023,
"preview": "# ¡Hora del Examen!\n\n¡Buen trabajo al estudiar el material sobre `smolagents`! Ya has logrado mucho. Ahora, es momento d"
},
{
"path": "units/es/unit2/smolagents/introduction.mdx",
"chars": 7178,
"preview": "# Introducción a `smolagents`\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/uni"
},
{
"path": "units/es/unit2/smolagents/multi_agent_systems.mdx",
"chars": 21363,
"preview": "<CourseFloatingBanner chapter={2}\n classNames=\"absolute z-10 right-0 top-0\"\n notebooks={[\n {label: \"Google Colab\", "
},
{
"path": "units/es/unit2/smolagents/quiz1.mdx",
"chars": 7061,
"preview": "# Pequeño Quiz (no calificado) [[quiz1]]\n\n¡Vamos a poner a prueba tu comprensión de `smolagents` con un quiz rápido! Rec"
},
{
"path": "units/es/unit2/smolagents/quiz2.mdx",
"chars": 7659,
"preview": "# Pequeño Quiz (no calificado) [[quiz2]]\n\nEs hora de poner a prueba tu comprensión de las secciones *Agentes de Código*,"
},
{
"path": "units/es/unit2/smolagents/retrieval_agents.mdx",
"chars": 9746,
"preview": "<CourseFloatingBanner chapter={2}\n classNames=\"absolute z-10 right-0 top-0\"\n notebooks={[\n {label: \"Google Colab\", "
},
{
"path": "units/es/unit2/smolagents/tool_calling_agents.mdx",
"chars": 4459,
"preview": "<CourseFloatingBanner chapter={2}\n classNames=\"absolute z-10 right-0 top-0\"\n notebooks={[\n {label: \"Google Colab\", "
},
{
"path": "units/es/unit2/smolagents/tools.mdx",
"chars": 15063,
"preview": "<CourseFloatingBanner chapter={2}\n classNames=\"absolute z-10 right-0 top-0\"\n notebooks={[\n {label: \"Google Colab\", "
},
{
"path": "units/es/unit2/smolagents/vision_agents.mdx",
"chars": 13348,
"preview": "<CourseFloatingBanner chapter={2}\n classNames=\"absolute z-10 right-0 top-0\"\n notebooks={[\n {label: \"Google Colab\", "
},
{
"path": "units/es/unit2/smolagents/why_use_smolagents.mdx",
"chars": 5531,
"preview": "![smolagents banner](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/smolagents/license_to"
},
{
"path": "units/es/unit3/README.md",
"chars": 0,
"preview": ""
},
{
"path": "units/es/unit3/agentic-rag/agent.mdx",
"chars": 20377,
"preview": "# Creando tu Agente para la Gala\n\nAhora que hemos construido todos los componentes necesarios para Alfred, es momento de"
},
{
"path": "units/es/unit3/agentic-rag/agentic-rag.mdx",
"chars": 2121,
"preview": "# Generación Aumentada por Recuperación con Agentes (RAG Agéntico)\n\nEn esta unidad, veremos cómo podemos usar RAG Agénti"
},
{
"path": "units/es/unit3/agentic-rag/conclusion.mdx",
"chars": 1256,
"preview": "# Conclusión\n\nEn esta unidad, hemos aprendido a crear un sistema RAG agéntico para ayudar a Alfred, nuestro amigable age"
},
{
"path": "units/es/unit3/agentic-rag/introduction.mdx",
"chars": 3309,
"preview": "# Introducción al Caso de Uso para RAG Agéntico\n\n![Banner de RAG Agéntico](https://huggingface.co/datasets/agents-course"
},
{
"path": "units/es/unit3/agentic-rag/invitees.mdx",
"chars": 19214,
"preview": "# Creando una Herramienta RAG para Historias de Invitados\n\n\nAlfred, tu agente de confianza, está preparando la gala más "
},
{
"path": "units/es/unit3/agentic-rag/tools.mdx",
"chars": 14531,
"preview": "# Construyendo e Integrando Herramientas para Tu Agente\n\nEn esta sección, le daremos a Alfred acceso a la web, permitién"
},
{
"path": "units/es/unit4/README.md",
"chars": 0,
"preview": ""
},
{
"path": "units/es/unit4/additional-readings.mdx",
"chars": 1849,
"preview": "# ¿Y ahora? ¿Qué temas debería aprender?\n\nLa IA Agéntica es un campo en rápida evolución, y comprender los protocolos fu"
},
{
"path": "units/es/unit4/conclusion.mdx",
"chars": 617,
"preview": "# Conclusión\n\n**¡Felicitaciones por terminar el Curso de Agentes!**\n\nA través de la perseverancia y la dedicación, has c"
},
{
"path": "units/es/unit4/get-your-certificate.mdx",
"chars": 990,
"preview": "# Reclama tu Certificado 🎓\n\nSi obtuviste una puntuación **superior al 30%, ¡felicitaciones! 👏 Ahora eres elegible para r"
},
{
"path": "units/es/unit4/hands-on.mdx",
"chars": 3787,
"preview": "# Práctica\n\nAhora que estás listo/a para profundizar en la creación de tu agente final, veamos cómo puedes enviarlo para"
},
{
"path": "units/es/unit4/introduction.mdx",
"chars": 1732,
"preview": "# Bienvenido/a a la última Unidad [[introduccion]]\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-image"
},
{
"path": "units/es/unit4/what-is-gaia.mdx",
"chars": 4515,
"preview": "# ¿Qué es GAIA?\n\n[GAIA](https://huggingface.co/papers/2311.12983) es un **benchmark diseñado para evaluar asistentes de "
},
{
"path": "units/fr/_toctree.yml",
"chars": 6502,
"preview": "- title: Unité 0. Bienvenue dans le cours\n sections:\n - local: unit0/introduction\n title: Bienvenue dans le cours 🤗"
},
{
"path": "units/fr/bonus-unit1/conclusion.mdx",
"chars": 827,
"preview": "# Conclusion [[conclusion]]\n\nFélicitations pour avoir terminé cette première Unité Bonus 🥳\n\nVous **maîtrisez la compréhe"
},
{
"path": "units/fr/bonus-unit1/fine-tuning.mdx",
"chars": 4379,
"preview": "# Finetunons un modèle pour pouvoir faire de l'appel de fonctions\n\nNous sommes maintenant prêts à finetuner notre premie"
},
{
"path": "units/fr/bonus-unit1/introduction.mdx",
"chars": 3335,
"preview": "# Introduction\n\n![Bonus Unit 1 Thumbnail](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/bo"
},
{
"path": "units/fr/bonus-unit1/what-is-function-calling.mdx",
"chars": 3946,
"preview": "# Qu'est-ce que l'appel de fonctions ?\n\nTout comme les outils, l'appel de fonctions (*function-calling*) est une **façon"
},
{
"path": "units/fr/bonus-unit2/introduction.mdx",
"chars": 2011,
"preview": "# Introduction\n\n![Bonus Unit 2 Thumbnail](https://langfuse.com/images/cookbook/huggingface-agent-course/agent-observabil"
},
{
"path": "units/fr/bonus-unit2/monitoring-and-evaluating-agents-notebook.mdx",
"chars": 19780,
"preview": "<CourseFloatingBanner chapter={2}\n classNames=\"absolute z-10 right-0 top-0\"\n notebooks={[\n {label: \"Google Colab\", "
},
{
"path": "units/fr/bonus-unit2/quiz.mdx",
"chars": 5744,
"preview": "# Quiz : évaluation des agents\n\nÉvaluons votre compréhension des concepts de traçage et d'évaluation des agents abordés "
},
{
"path": "units/fr/bonus-unit2/what-is-agent-observability-and-evaluation.mdx",
"chars": 12244,
"preview": "# Qu'est-ce que l'observabilité et l'évaluation des agents ?\n\n## 🔎 Qu'est-ce que l'Observabilité ?\n\nL'observabilité cons"
},
{
"path": "units/fr/bonus-unit3/building_your_pokemon_agent.mdx",
"chars": 13103,
"preview": "# Construire un agent de combat Pokémon\n\nMaintenant que vous avez exploré le potentiel et les limitations de l'IA agenti"
},
{
"path": "units/fr/bonus-unit3/conclusion.mdx",
"chars": 1180,
"preview": "# Conclusion\n\nSi vous êtes arrivé jusqu'ici, félicitations ! 🥳 Vous avez construit avec succès votre propre agent de com"
},
{
"path": "units/fr/bonus-unit3/from-llm-to-agents.mdx",
"chars": 3162,
"preview": "# Des LLM aux agents\n\nNous avons appris dans la [première unité](https://huggingface.co/learn/agents-course/unit1/introd"
},
{
"path": "units/fr/bonus-unit3/introduction.mdx",
"chars": 2121,
"preview": "# Introduction\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/bonus-unit3/pokemo"
},
{
"path": "units/fr/bonus-unit3/launching_agent_battle.mdx",
"chars": 3120,
"preview": "# Lancer l'agent de combat Pokémon\n\nIl est maintenant temps de combattre ! ⚡️\n\n## **Combattez l'agent de Stream !**\n\nSi "
},
{
"path": "units/fr/bonus-unit3/state-of-art.mdx",
"chars": 3287,
"preview": "# L'état de l'art de l'utilisation des LLM dans les jeux\n\nPour vous donner une idée de l'ampleur des progrès réalisés da"
},
{
"path": "units/fr/communication/live1.mdx",
"chars": 841,
"preview": "# Sessions en direct 1 : Comment fonctionne le cours et première session de questions-réponses\n\nDans cette première sess"
},
{
"path": "units/fr/unit0/discord101.mdx",
"chars": 2926,
"preview": "# (Optionnel) Introduction à Discord [[discord-101]]\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-ima"
},
{
"path": "units/fr/unit0/introduction.mdx",
"chars": 10446,
"preview": "# Bienvenue dans le cours 🤗 [[introduction]]\n\n<figure>\n<img src=\"https://huggingface.co/datasets/agents-course/course-im"
},
{
"path": "units/fr/unit0/onboarding.mdx",
"chars": 4704,
"preview": "# Embarquement : vos premiers pas ⛵\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-images/resolve/main/"
},
{
"path": "units/fr/unit1/README.md",
"chars": 1723,
"preview": "# Table des matières\n\nVous pouvez accéder à l'Unité 1 sur hf.co/learn 👉 <a href=\"https://hf.co/learn/agents-course/unit1"
},
{
"path": "units/fr/unit1/actions.mdx",
"chars": 7316,
"preview": "# Actions : permettre à l'agent d'interagir avec son environnement\n\n> [!TIP]\n> Dans cette section, nous explorons les ét"
},
{
"path": "units/fr/unit1/agent-steps-and-structure.mdx",
"chars": 7269,
"preview": "# Comprendre les agents à travers le cycle Réflexion-Action-Observation\n\n<img src=\"https://huggingface.co/datasets/agent"
},
{
"path": "units/fr/unit1/conclusion.mdx",
"chars": 1349,
"preview": "# Conclusion [[conclusion]]\n\nFélicitations pour avoir terminé cette première Unité 🥳\n\nVous **maîtrisez les fondamentaux*"
},
{
"path": "units/fr/unit1/dummy-agent-library.mdx",
"chars": 12348,
"preview": "# Bibliothèque d'agents factices\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/"
},
{
"path": "units/fr/unit1/final-quiz.mdx",
"chars": 1668,
"preview": "# Quiz final de l'Unité 1\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/w"
},
{
"path": "units/fr/unit1/introduction.mdx",
"chars": 2063,
"preview": "# Introduction aux agents\n\n<img src=\"https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/t"
}
]
// ... and 239 more files (download for full content)
About this extraction
This page contains the full source code of the huggingface/agents-course GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 439 files (2.2 MB), approximately 595.4k tokens, and a symbol index with 2 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.