Tool Calling in AI Agents: NCP-AAI Function Integration Guide

Tool use and function calling represent the core capabilities that distinguish agentic AI from traditional chatbots. The NVIDIA Certified Professional - Agentic AI (NCP-AAI) exam dedicates 15-18% of questions to tool integration, function calling, and external system interaction—making this one of the highest-weighted topics. This definitive guide covers every concept you need for exam success and production deployment, from schema design and protocol differences across providers to NVIDIA's AIQ Toolkit, NeMo Agent Toolkit with MCP support, Llama Nemotron benchmarks, and real-world enterprise case studies.

What is Tool Use in Agentic AI?

Tool use enables AI agents to extend their capabilities beyond text generation by interacting with external systems, APIs, databases, and software tools. This transforms passive language models into active agents that can:

• Execute actions (send emails, update databases, control IoT devices)
• Retrieve information (query APIs, search databases, fetch real-time data)
• Perform calculations (run code, solve equations, analyze data)
• Orchestrate workflows (chain multiple tools, handle dependencies)
• Interact with users (collect input, display results, request clarifications)
• Integrate with enterprise systems (CRM, ERP, ticketing, compliance)
• Control physical systems (IoT, robotics via API bridges)

The Paradigm Shift: From Chatbot to Agent

Traditional LLMs (Without Tool Calling):

User: "What's the weather in Tokyo?"
LLM: "I don't have access to real-time weather data,
      but you can check weather.com or similar services."

Agentic AI (With Tool Calling):

User: "What's the weather in Tokyo?"
Agent: [Calls get_weather_data(city="Tokyo", country="JP")]
       [Receives: {"temp": 18, "condition": "Partly cloudy"}]
Agent: "The current weather in Tokyo is 18°C and partly cloudy."

This shift is foundational. According to NVIDIA's 2025 Agentic AI adoption report, 89% of production AI agents use tool calling capabilities and 73% of enterprise agentic workflows integrate with three or more external systems. On the NCP-AAI exam, 94% of scenarios involve agents with tool access—making this topic unavoidable.

NCP-AAI Exam Coverage: What You Need to Know

Exam Domain Breakdown

Exam Format: Expect scenario-based questions testing practical tool selection, error diagnosis, and performance optimization—not abstract theory.

Function Calling: Core Concepts

Anatomy of a Function Call

Function calling follows a structured protocol where the agent converts natural language into formatted tool invocations:

1. Tool Schema Definition (What the Exam Tests):

{
  "name": "get_weather",
  "description": "Retrieves current weather data for a specified location",
  "parameters": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string",
        "description": "City name or zip code"
      },
      "units": {
        "type": "string",
        "enum": ["celsius", "fahrenheit"],
        "default": "fahrenheit"
      }
    },
    "required": ["location"]
  }
}

Exam Tip: Know the difference between required and optional parameters. A common trap question asks which parameters must be provided.

2. Agent Reasoning and Tool Selection:

User: "What's the weather in Tokyo?"
Agent Internal Reasoning:
  - Intent: Get weather information
  - Required tool: get_weather
  - Extract parameters: location = "Tokyo"
  - Generate function call

3. Function Call Execution:

{
  "tool": "get_weather",
  "parameters": {
    "location": "Tokyo",
    "units": "celsius"
  }
}

4. Tool Response Integration:

{
  "tool": "get_weather",
  "result": {
    "temperature": 18,
    "conditions": "Partly cloudy",
    "humidity": 65
  }
}

5. Agent Response to User:

"The weather in Tokyo is currently 18°C (64°F) with partly cloudy skies."

Exam Question Example: "An agent receives tool result with status 200 but empty data. Which component failed?"

• Answer: Tool implementation (not schema, agent, or orchestrator).

Key Schema Components

Native Function Calling Across Providers

Understanding protocol differences is critical for the NCP-AAI exam, which tests cross-platform tool integration.

OpenAI Function Calling Protocol

OpenAI wraps function definitions inside a tools array, with each tool typed as "function":

import openai

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get current weather for a location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "City name, e.g., 'San Francisco'"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Temperature unit"
                    }
                },
                "required": ["location"]
            }
        }
    }
]

response = openai.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "What's the weather in SF?"}],
    tools=tools,
    tool_choice="auto"
)

if response.choices[0].message.tool_calls:
    tool_call = response.choices[0].message.tool_calls[0]
    function_name = tool_call.function.name
    function_args = json.loads(tool_call.function.arguments)

    result = get_weather(**function_args)

    messages.append(response.choices[0].message)
    messages.append({
        "role": "tool",
        "tool_call_id": tool_call.id,
        "content": json.dumps(result)
    })

    final_response = openai.chat.completions.create(
        model="gpt-4",
        messages=messages
    )

Key OpenAI Parameters:

• tool_choice="auto": Model decides when to call tools
• tool_choice="required": Force a tool call
• tool_choice={"type": "function", "function": {"name": "get_weather"}}: Force a specific tool

Anthropic Claude Tool Use Protocol

Claude uses a different schema structure and response format. Tool definitions use input_schema instead of parameters, and tool calls return as tool_use content blocks:

import anthropic

client = anthropic.Anthropic()

tools = [
    {
        "name": "get_weather",
        "description": "Get current weather for a location",
        "input_schema": {
            "type": "object",
            "properties": {
                "location": {"type": "string", "description": "City name"},
                "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
            },
            "required": ["location"]
        }
    }
]

message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=tools,
    messages=[{"role": "user", "content": "Weather in NYC?"}]
)

if message.stop_reason == "tool_use":
    tool_use = next(
        block for block in message.content if block.type == "tool_use"
    )
    result = get_weather(**tool_use.input)

    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        tools=tools,
        messages=[
            {"role": "user", "content": "Weather in NYC?"},
            {"role": "assistant", "content": message.content},
            {
                "role": "user",
                "content": [
                    {
                        "type": "tool_result",
                        "tool_use_id": tool_use.id,
                        "content": json.dumps(result)
                    }
                ]
            }
        ]
    )

Protocol Differences: OpenAI vs. Anthropic (Exam-Testable)

Exam Question: "When migrating an agent from OpenAI to Anthropic, which schema key must change?"

• Answer: parameters must become input_schema, and tool results use tool_result content blocks instead of role: tool messages.

Claude-Specific Capabilities:

• Server-side tools: Claude can execute web_search, code_execution, and web_fetch on Anthropic's infrastructure without client handling
• Tool search: Dynamically discovers tools from large catalogs without consuming context window
• Prompt caching: Caches tool definitions across requests for lower latency
• Programmatic tool calling: Invokes tools within a code execution environment, reducing context window consumption

NVIDIA NIM Function Calling Format

When using NVIDIA NIM with models like Llama Nemotron, the function calling format follows the OpenAI-compatible API but with NVIDIA-specific model endpoints:

from langchain_nvidia_ai_endpoints import ChatNVIDIA

llm = ChatNVIDIA(
    model="nvidia/llama-3.3-nemotron-super-49b-v1.5",
    nvidia_api_key="nvapi-...",
    temperature=0.2
)

# Tool binding follows LangChain conventions
llm_with_tools = llm.bind_tools(tools)
response = llm_with_tools.invoke("What's the weather in Tokyo?")

Exam Tip: NIM uses OpenAI-compatible endpoints, so schema format follows the OpenAI convention (parameters, not input_schema). This is a common exam question testing whether you know which format to use with which provider.

When to Use Each Provider's Format

The ReAct Pattern with Tool Calling

The ReAct (Reason + Act) pattern is one of the most tested concepts on the NCP-AAI exam. It structures agent behavior as an interleaved loop of reasoning and tool execution:

ReAct Format

Thought: [Reasoning about what to do next]
Action: [Tool name to invoke]
Action Input: [Tool arguments as structured input]
Observation: [Tool result returned by the system]
... (repeat Thought/Action/Observation as needed)
Thought: I now know the final answer
Final Answer: [Response to user]

ReAct in Practice: Multi-Step Example

from langchain.agents import create_react_agent, AgentExecutor

tools = [
    Tool(name="Search", func=search_web, description="Search the web"),
    Tool(name="Calculator", func=calculator, description="Do math"),
    Tool(name="Weather", func=get_weather, description="Get weather")
]

agent = create_react_agent(llm, tools, react_prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

result = executor.invoke({
    "input": "What's the average temperature in the 5 largest US cities?"
})

# Agent execution trace:
# Thought: I need to find the 5 largest US cities
# Action: Search
# Action Input: "5 largest US cities by population"
# Observation: New York, Los Angeles, Chicago, Houston, Phoenix
# Thought: Now I need weather for each city
# Action: Weather
# Action Input: "New York"
# Observation: 45°F
# Action: Weather
# Action Input: "Los Angeles"
# Observation: 68°F
# ... (continues for remaining cities)
# Thought: Now I need to calculate average
# Action: Calculator
# Action Input: "(45 + 68 + 52 + 73 + 75) / 5"
# Observation: 62.6
# Thought: I now know the final answer
# Final Answer: The average temperature is 62.6°F

Tool-Calling Agent vs. ReAct Agent (AIQ Toolkit)

NVIDIA's AIQ Toolkit supports both patterns with distinct tradeoffs:

Exam Question: "A customer support agent needs less than 500ms response time. Which pattern?"

• Answer: Tool-Calling Agent (ReAct adds reasoning latency at each step).

Tool Use Patterns (High Exam Frequency)

1. Sequential Tool Chains

Tools executed one after another, where each output informs the next:

Exam Scenario:

User: "Book the cheapest flight to Paris next week"
Sequential Chain:
  1. get_calendar(date_range="next_week") -> Returns: Dec 16-22 available
  2. search_flights(dest="Paris", dates="Dec 16-22") -> Returns: 3 options
  3. find_cheapest(flight_list) -> Returns: Flight AF123 ($487)
  4. book_flight(flight_id="AF123") -> Returns: Confirmation PNR456

Key Exam Concept: Sequential chains have dependencies—step N requires output from step N-1. If step 2 fails, steps 3-4 cannot execute.

2. Parallel Tool Execution

Independent tools run simultaneously for efficiency:

Exam Scenario:

User: "Compare weather in Tokyo, London, and New York"
Parallel Execution:
  get_weather(location="Tokyo")    -> 18°C, Cloudy
  get_weather(location="London")   -> 12°C, Rainy
  get_weather(location="New York") -> 8°C, Snowy

  [All execute simultaneously, wait for all results, then respond]

import asyncio

async def parallel_tool_agent(query):
    response = await llm.agenerate(messages=[
        {"role": "user", "content": query}
    ])

    tool_calls = response.tool_calls
    tasks = [execute_tool(tc.name, tc.args) for tc in tool_calls]
    results = await asyncio.gather(*tasks)

    final_response = await llm.agenerate(
        messages=[
            {"role": "user", "content": query},
            {"role": "assistant", "tool_calls": tool_calls},
            {"role": "tool", "tool_results": results}
        ]
    )
    return final_response

Benefits:

• Latency reduction: 3 parallel calls vs. 3 sequential = up to 3x faster
• Scalability: Handles multiple independent operations efficiently

3. Conditional Tool Selection

Agent chooses tools based on context or previous results:

Exam Scenario:

User: "What's my account balance?"
Conditional Logic:
  1. get_account_balance(user_id=123) -> Returns: $47.21
  2. IF balance < $100:
       send_alert(message="Low balance warning")
     ELSE:
       No action needed

Router Pattern for Large Tool Sets:

def route_to_specialist(query):
    category = classifier_llm.predict(query)

    if category == "web_search":
        agent = initialize_agent(web_tools, llm)
    elif category == "data_analysis":
        agent = initialize_agent(data_tools, llm)
    elif category == "code_execution":
        agent = initialize_agent(code_tools, llm)

    return agent.run(query)

Advantages of routing:

• Agent chooses from a smaller, relevant tool set (reduces confusion)
• Specialized prompts and strategies per category
• Limits tool access per query type for security

Exam Question: "Which pattern is BEST when tool selection depends on runtime data?"

• Answer: Conditional tool selection (not sequential or parallel).

4. Recursive Tool Calls

Agent calls the same tool multiple times with evolving parameters:

Exam Scenario:

User: "Summarize all documents in folder /reports"
Recursive Pattern:
  1. list_files(path="/reports") -> Returns: [doc1.pdf, doc2.pdf, doc3.pdf]
  2. FOR EACH file:
       read_document(file_path) -> Extract text
       summarize_text(text) -> Generate summary
  3. Combine all summaries

Exam Focus: Know limitations—recursive depth limits (typically 5-10 iterations) and timeout handling.

5. Hierarchical Tool Composition

Complex tools built from simpler primitives:

from langchain.tools import StructuredTool

def read_file(filepath: str) -> str:
    with open(filepath) as f:
        return f.read()

def write_file(filepath: str, content: str) -> str:
    with open(filepath, 'w') as f:
        f.write(content)
    return "File written successfully"

def refactor_code(filepath: str, instructions: str) -> str:
    """Refactor code file based on instructions"""
    code = read_file(filepath)
    refactored = llm.predict(
        f"Refactor this code:\n{code}\n\nInstructions: {instructions}"
    )
    write_file(filepath, refactored)
    return f"Refactored {filepath}"

tools = [StructuredTool.from_function(refactor_code)]
agent = initialize_agent(tools, llm)
result = agent.run("Refactor main.py to use async/await")

Benefits:

• Abstraction: Hides complexity from the agent
• Reusability: Composes tools into higher-level operations
• Reliability: Pre-tested compositions reduce agent errors

The Complete Tool Calling Execution Flow

Understanding the full lifecycle of a tool call is critical for diagnosing failures on the exam.

Standard Agent-Tool Interaction Cycle

 1. User Query
    "Book a meeting room for 3pm tomorrow"
         |
         v
 2. Agent Reasoning (LLM)
    - Parse intent: book meeting room
    - Identify required tool: check_room_availability()
    - Extract parameters: time=15:00, date=tomorrow
         |
         v
 3. Tool Call Generation
    Function: check_room_availability
    Parameters: {
      "datetime": "2026-04-01T15:00:00",
      "duration_minutes": 60,
      "capacity": 1
    }
         |
         v
 4. Tool Execution (External System)
    - Queries calendar API
    - Returns available rooms: [Room_402, Room_515]
         |
         v
 5. Result Processing (Agent)
    - Receives room list
    - Calls book_room(room_id="Room_402")
    - Confirmation received
         |
         v
 6. Response Generation
    "I've booked Room 402 for you tomorrow at 3pm."

Exam Focus: The exam tests your ability to identify which step failed given a symptom. For example:

• Agent generates correct tool call but wrong parameters extracted = Step 2 failure (reasoning)
• Tool call is correct but returns an error = Step 4 failure (execution)
• Tool succeeds but agent generates incorrect response = Step 6 failure (response generation)
• Agent does not attempt a tool call at all = Step 2 failure (intent parsing or tool selection)

Execution Timing Breakdown

Understanding where time is spent helps with optimization questions:

Exam Tip: The tool execution step (external API call) is almost always the slowest component. Caching and parallel execution are the highest-impact optimizations.

Tool Categories for Enterprise Agents

Production agents typically use 8-12 tools across these categories:

1. Data Access Tools

Purpose: Query databases, APIs, knowledge bases

• sql_query(query: str) -> DataFrame
• api_request(endpoint: str, method: str, params: dict) -> dict
• vector_search(query: str, top_k: int) -> List[Document]
• knowledge_graph_query(cypher: str) -> List[Node]

NCP-AAI Focus: RAG pipelines, knowledge integration patterns

2. Computation Tools

Purpose: Perform calculations, data transformations

• calculate(expression: str) -> float
• python_repl(code: str) -> Any
• data_analysis(dataframe: str, operation: str) -> dict
• statistical_test(data: List[float], test_type: str) -> dict

NCP-AAI Focus: Code execution safety, sandboxing

3. Communication Tools

Purpose: Send notifications, update systems

• send_email(to: str, subject: str, body: str) -> bool
• post_slack_message(channel: str, text: str) -> bool
• create_jira_ticket(project: str, summary: str) -> str
• update_crm(contact_id: str, fields: dict) -> bool

NCP-AAI Focus: Integration patterns, error handling

4. File Operations

Purpose: Read, write, transform documents

• read_file(path: str) -> str
• write_file(path: str, content: str) -> bool
• parse_pdf(file_path: str) -> dict
• generate_report(template: str, data: dict) -> bytes

NCP-AAI Focus: Security, access control, file system isolation

5. Web Interaction

Purpose: Browser automation, web scraping

• fetch_url(url: str) -> str
• click_element(selector: str) -> bool
• fill_form(form_id: str, data: dict) -> bool
• extract_table(url: str, table_selector: str) -> DataFrame

NCP-AAI Focus: Browser-use integration, Playwright and Selenium patterns

Tool Count and Agent Performance

Research from NVIDIA (2025) shows a clear relationship between the number of tools available to an agent and its tool selection accuracy:

Exam Question: "An agent with 40 tools frequently selects the wrong tool. What architectural change has the greatest impact?"

• Answer: Implement tool routing with specialist sub-agents. Split the 40 tools into 3-4 categories with a router agent that delegates to specialist agents with 10-12 tools each. This keeps each agent's tool count in the high-accuracy range.

This is where the hierarchical composition and tool delegation patterns discussed earlier become essential in production systems

RAG-Integrated Tool Patterns

Retrieval-Augmented Generation is one of the most important tool-calling use cases on the NCP-AAI exam. These patterns extend basic RAG with advanced retrieval strategies.

Multi-Query RAG

Instead of a single retrieval query, the agent generates multiple reformulations to improve recall:

def multi_query_rag(user_question: str, retriever, llm) -> str:
    """Generate multiple query variants for broader retrieval."""
    query_prompt = f"""Generate 3 different search queries to answer:
    '{user_question}'
    Return one query per line."""

    queries = llm.predict(query_prompt).strip().split("\n")

    all_docs = set()
    for query in queries:
        docs = retriever.retrieve(query, top_k=5)
        all_docs.update(docs)

    context = "\n".join([doc.text for doc in all_docs])
    return llm.predict(f"Context: {context}\n\nQuestion: {user_question}")

Exam Tip: Multi-query RAG is the answer when a single query retrieves only partial context.

Parent Document Retrieval

Store small chunks for embedding but return the full parent document for context:

from langchain.retrievers import ParentDocumentRetriever
from langchain.storage import InMemoryStore

parent_store = InMemoryStore()
retriever = ParentDocumentRetriever(
    vectorstore=vectorstore,       # Stores child chunks
    docstore=parent_store,         # Stores full parent documents
    child_splitter=RecursiveCharacterTextSplitter(chunk_size=200),
    parent_splitter=RecursiveCharacterTextSplitter(chunk_size=2000),
)

How it works:

1. Documents are split into small chunks (200 tokens) for precise semantic search
2. When a chunk matches, the full parent document (2000 tokens) is returned
3. Agent receives richer context without losing retrieval precision

Exam Question: "An agent retrieves relevant snippets but lacks surrounding context. Which RAG pattern fixes this?"

• Answer: Parent document retrieval (returns full parent instead of just the matched chunk).

Self-Query Retrieval

The agent generates both a semantic query AND metadata filters from the user's natural language:

from langchain.retrievers import SelfQueryRetriever

retriever = SelfQueryRetriever.from_llm(
    llm=llm,
    vectorstore=vectorstore,
    document_contents="Technical documentation for NVIDIA products",
    metadata_field_info=[
        {"name": "product", "type": "string",
         "description": "Product name (e.g., NIM, NeMo, Triton)"},
        {"name": "version", "type": "float",
         "description": "Version number"},
        {"name": "doc_type", "type": "string",
         "description": "Type: tutorial, reference, troubleshooting"},
    ]
)

# User query: "NeMo troubleshooting guides for version 2.0+"
# Agent generates:
#   semantic_query = "troubleshooting guides"
#   filters = { product: "NeMo", version: >= 2.0, doc_type: "troubleshooting" }

Exam Relevance: Self-query retrieval eliminates irrelevant results when users implicitly filter by metadata (dates, categories, versions).

Comparing RAG Tool Patterns

Exam Question: "A user asks 'Show me NeMo troubleshooting docs from 2025.' Which RAG pattern best handles this?"

• Answer: Self-query retrieval, because the query contains both a semantic component ("troubleshooting docs") and implicit metadata filters (product="NeMo", year=2025).

Tool Selection Scoring

When an agent has access to many tools, it must score and rank which tool best fits the user's intent. This is a testable concept on the NCP-AAI exam.