# Implementing Function Calling and Tool Use in AI Agents: A Complete Guide to the ai-engineering-from-scratch Curriculum

> Master function calling and tool use in AI agents with the ai-engineering-from-scratch curriculum. Learn a four-step loop for modular AI development. Get the complete guide.

- Repository: [Rohit Ghumare/ai-engineering-from-scratch](https://github.com/rohitg00/ai-engineering-from-scratch)
- Tags: how-to-guide
- Published: 2026-07-26

---

**The ai-engineering-from-scratch repository provides a phase-driven curriculum that teaches function calling through a four-step loop—tool definition, model parsing, execution, and result injection—using a modular architecture that abstracts provider-specific APIs into a unified transport layer.**

This comprehensive open-source curriculum walks learners from first principles to production-grade AI agents, with **implementing function calling and tool use in AI agents** serving as a core competency developed across Phases 13 and 14. The repository treats function calling as a standardized transport protocol, enabling seamless portability across OpenAI, Anthropic, Gemini, and custom MCP servers.

## The Four-Step Function Calling Loop

According to the source code in [`phases/13-tools-and-protocols/01-the-tool-interface/docs/en.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/13-tools-and-protocols/01-the-tool-interface/docs/en.md), the curriculum codifies function calling into a reproducible execution cycle that bridges LLM token generation with host-side actions.

### 1. Tool Interface Definition

The process begins with a **JSON-Schema contract** that declares available tools, their parameters, and type constraints. This schema lives in lesson documentation (e.g., [`phases/13-tools-and-protocols/02-function-calling-deep-dive/docs/en.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/13-tools-and-protocols/02-function-calling-deep-dive/docs/en.md)) and provides the LLM with structured metadata about what functions it can invoke and how arguments must be formatted.

### 2. Model Output Parsing

When the LLM decides to invoke a tool, it returns provider-specific payloads—`function_call` for OpenAI, `tool_use` for Anthropic, or `functionDeclarations` for Gemini. The curriculum's **Tool Registry** pattern (documented in [`outputs/skill-function-calling-patterns.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/outputs/skill-function-calling-patterns.md)) normalizes these disparate formats into a unified internal representation.

### 3. Tool Execution

The host program looks up the requested tool in the registry, validates incoming arguments against the JSON schema, and executes the implementation. As shown in [`phases/13-tools-and-protocols/02-function-calling-deep-dive/code/main.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/13-tools-and-protocols/02-function-calling-deep-dive/code/main.py), this step includes exception handling to capture runtime errors for safe return to the model.

### 4. Result Injection

The tool's output is serialized and re-inserted into the conversation context, allowing the LLM to continue reasoning with fresh data. This closes the loop and enables multi-turn tool use workflows essential for complex agentic tasks.

## Repository Architecture for Tool Use

The repository organizes its function calling curriculum into five distinct architectural layers, as defined in the root [`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md) contract:

- **Curriculum Core**: Lessons are grouped into phases, with tool-specific content concentrated in `phases/13-tools-and-protocols/` and `phases/14-agent-engineering/`
- **Lesson Assets**: Each lesson contains [`docs/en.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/docs/en.md) for theory, `code/main.*` for implementations, and `code/tests/` for validation
- **Reusable Skills**: Centralized artifacts in `outputs/skills/` and `outputs/agents/` store tool definitions and MCP server configurations that lessons emit for production use
- **Build Pipeline**: [`site/build.js`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/site/build.js) and [`scripts/build_catalog.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/scripts/build_catalog.py) transform the markdown curriculum into searchable documentation and e-books
- **Project Metadata**: [`ROADMAP.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/ROADMAP.md) and [`glossary/terms.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/glossary/terms.md) standardize terminology across the function calling implementations

## Practical Implementation Examples

### Scaffolding a New Lesson

The repository includes automation scripts to standardize lesson creation. To scaffold a new function calling lesson under Phase 13:

```bash
scripts/scaffold-lesson.sh 13 tool-use-and-function-calling my-new-lesson

```

This generates the required directory structure (`docs/`, `code/`, `code/tests/`, [`quiz.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/quiz.json)) with template content adhering to the [`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md) conventions.

### Defining Tool Interfaces in Python

The following implementation from [`phases/13-tools-and-protocols/02-function-calling-deep-dive/code/main.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/13-tools-and-protocols/02-function-calling-deep-dive/code/main.py) demonstrates a simple tool with proper JSON serialization:

```python
"""Tool: web_search – fetches the first result for a query."""
import json
import urllib.request

def web_search(query: str) -> str:
    # Very naive search; replace with a real API in production

    url = f"https://duckduckgo.com/html/?q={urllib.parse.quote(query)}"
    html = urllib.request.urlopen(url).read().decode()
    # Return the first <a> href we can find

    start = html.find('href="') + 6
    end = html.find('"', start)
    return html[start:end]

if __name__ == "__main__":
    # Simple CLI for manual testing

    import sys
    print(json.dumps({"result": web_search(" ".join(sys.argv[1:]))}))

```

The accompanying schema in the lesson's [`docs/en.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/docs/en.md) specifies that this tool expects a single string argument named `query`, enabling the LLM to generate properly structured calls.

### Testing Tool Execution

Validate the complete loop using the lesson's test suite:

```bash
cd phases/13-tools-and-protocols/02-function-calling-deep-dive/code
python3 -m unittest discover -v

```

The tests in [`code/tests/test_main.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/code/tests/test_main.py) verify that the Tool Registry correctly unmarshals model-generated JSON, invokes `web_search`, and propagates exceptions back to the LLM context.

## Advanced Patterns and Production Considerations

The curriculum addresses production complexities in [`phases/11-llm-engineering/09-function-calling/outputs/skill-function-calling-patterns.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/11-llm-engineering/09-function-calling/outputs/skill-function-calling-patterns.md), including:

- **Parallel Tool Calls**: Handling multiple simultaneous function invocations and aggregating results
- **Streaming Tool Results**: Incrementally returning data for long-running operations
- **Guardrails**: Security and cost-control mechanisms to prevent unauthorized tool execution or excessive API usage

A key architectural insight from Phase 13 is the **Multi-Caller Protocol (MCP)**, which abstracts provider-specific function-calling APIs into a unified transport layer. This abstraction—analogous to HTTP for networking—allows the same tool definitions to execute across different LLM providers without modifying lesson code.

## Summary

- The **ai-engineering-from-scratch** repository teaches function calling through a rigorous four-step loop: definition, parsing, execution, and injection
- **Phase 13 (Tools & Protocols)** and **Phase 14 (Agent Engineering)** contain the core curriculum for implementing function calling and tool use in AI agents
- The **Tool Registry** pattern and **MCP transport layer** provide cross-provider portability for OpenAI, Anthropic, and Gemini APIs
- The [`scripts/scaffold-lesson.sh`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/scripts/scaffold-lesson.sh) automation ensures consistent, test-driven lesson development
- Production-ready implementations require handling parallel calls, streaming results, and security guardrails as documented in the skill patterns output

## Frequently Asked Questions

### What is the MCP transport layer mentioned in the curriculum?

The **Multi-Caller Protocol (MCP)** is an architectural abstraction defined in Phase 13 that standardizes how tool definitions and execution requests flow between LLMs and host systems. According to the repository source code, MCP treats function calling as a transport layer similar to HTTP, enabling the same tool interfaces to work across OpenAI's `function_call`, Anthropic's `tool_use`, and Gemini's `functionDeclarations` without code changes.

### How does the repository handle different LLM provider formats?

The curriculum normalizes provider differences through the **Tool Registry** pattern implemented in lesson code. While OpenAI returns `function_call` objects and Anthropic returns `tool_use` blocks, the registry parses these into a unified internal format before execution. This abstraction is detailed in [`phases/13-tools-and-protocols/02-function-calling-deep-dive/docs/en.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/13-tools-and-protocols/02-function-calling-deep-dive/docs/en.md) and reused in later capstone projects.

### Where are the production security patterns documented?

Security guardrails and cost-control strategies for function calling are cataloged in [`phases/11-llm-engineering/09-function-calling/outputs/skill-function-calling-patterns.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/11-llm-engineering/09-function-calling/outputs/skill-function-calling-patterns.md). This file provides a decision framework for input validation, rate limiting, and error handling that prevents unauthorized tool execution and manages API expenditure in production environments.

### Can I add custom tools to the existing curriculum?

Yes. The repository provides [`scripts/scaffold-lesson.sh`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/scripts/scaffold-lesson.sh) to generate new lessons with the required structure (`docs/`, `code/`, `code/tests/`). When implementing custom tools, you must define the JSON schema in the lesson's documentation and implement the handler in [`code/main.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/code/main.py), following the four-step loop validated by the test suite in `code/tests/`.