Trigger a Real Tool Call

It's tempting to treat a decorator like @tool as opaque framework magic. It isn't — it inspects a plain Python function's type-hinted parameters and docstring, and from those, builds the exact JSON schema structure (name, description, parameters) the underlying tools API requires. You could write that schema by hand; @tool just automates a mechanical, error-prone step.

Nothing about tool calling changes the fundamental fact that an LLM only generates text — in this case, a specially structured tool_calls response instead of prose. Your own backend is still the thing that actually runs get_stock_price() and gets a real answer; the model's job stops at requesting that call with the right arguments.

Module 5 gives your LLM the ability to take actions, not just answer from text. LangChain's @tool decorator wraps a plain Python function, auto-generating the JSON schema an LLM API needs from the function's signature and docstring — you write normal Python, LangChain builds the schema.

Underneath the decorator, this is the exact same OpenAI tools API you may have used before — @tool just saves you from hand-writing the JSON schema for every function. This lesson calls that real API directly to make the mechanism fully visible.

Trigger a Real Tool Call. This is the exact schema @tool would generate for get_stock_price. Run it against a real model and check the response: instead of a text answer, you should see a structured tool_calls block requesting get_stock_price with ticker: "ACME" — the model choosing to act, not guessing a price.

What does LangChain's @tool decorator actually generate for you, that you'd otherwise have to write by hand?

• →The JSON schema (name, description, parameter types) the LLM API needs to understand and call the tool — inferred automatically from the function's signature and docstring.
• →It makes the LLM execute the Python function internally, inside the model itself.

The model chose to act instead of guessing. Next: the actual control loop — Thought, Action, Observation — that a real LangChain AgentExecutor runs to use a tool's result and decide what to do next.