Documentation Index
Fetch the complete documentation index at: https://docs.dedaluslabs.ai/llms.txt
Use this file to discover all available pages before exploring further.
A tool is a function you expose to a language model. Concretely, it specifies the input and output schema that describes what the function takes in and what it outputs.
Tool calling is useful because language models cannot execute code by itself. It can only specify which function should be invoked and how.
The manual way
Under the hood, tool calling is a three-step process.
- Describe the structure of the tool as a JSON schema and pass it to the model
- The model fills in the JSON schema and outputs it for the application to parse
- The application executes the tool call and send the results to the model
import json
from dedalus_labs import Dedalus
client = Dedalus()
def get_weather(city: str, units: str = "celsius") -> dict:
"""Get current weather for a city."""
return {"temp": 22, "conditions": "sunny"} # Toy example
tools = [
{
"type": "function",
"function": {
"name": "get_weather",
"description": "Get current weather for a city.",
"parameters": {
"type": "object",
"properties": {
"city": {"type": "string"},
"units": {"type": "string", "enum": ["celsius", "fahrenheit"]},
},
"required": ["city"],
},
},
}
]
response = client.chat.completions.create(
model="openai/gpt-4.1",
messages=[{"role": "user", "content": "Weather in Paris?"}],
tools=tools, # From step 1
)
# Process what the model responds with!
msg = response.choices[0].message
tool_call = msg.tool_calls[0]
args = json.loads(tool_call.function.arguments)
result = get_weather(args["city"], args.get("units", "celsius"))
final = client.chat.completions.create(
model="openai/gpt-4.1",
messages=[
{"role": "user", "content": "Weather in Paris?"},
msg,
{"role": "tool", "tool_call_id": tool_call.id, "content": json.dumps(result)},
],
tools=tools,
)
print(final.choices[0].message.content)
import json
from dedalus_labs import Dedalus
client = Dedalus()
def get_weather(city: str, units: str = "celsius") -> dict:
"""Get current weather for a city."""
return {"temp": 22, "conditions": "sunny"}
tools = [
{
"type": "function",
"function": {
"name": "get_weather",
"description": "Get current weather for a city.",
"parameters": {
"type": "object",
"properties": {
"city": {"type": "string"},
"units": {"type": "string", "enum": ["celsius", "fahrenheit"]},
},
"required": ["city"],
},
},
}
]
response = client.chat.completions.create(
model="openai/gpt-4.1",
messages=[{"role": "user", "content": "Weather in Paris?"}],
tools=tools,
)
msg = response.choices[0].message
tool_call = msg.tool_calls[0]
args = json.loads(tool_call.function.arguments)
result = get_weather(args["city"], args.get("units", "celsius"))
final = client.chat.completions.create(
model="openai/gpt-4.1",
messages=[
{"role": "user", "content": "Weather in Paris?"},
msg,
{"role": "tool", "tool_call_id": tool_call.id, "content": json.dumps(result)},
],
tools=tools,
)
print(final.choices[0].message.content)
The Dedalus Way
The DedalusRunner supports automatic tool calling serialization.
This means that it handles schema extraction, tool dispatch, conversation looping, and final response handling. All you have to do is pass in your function into the tools parameter!
from dedalus_labs import Dedalus, DedalusRunner
def get_weather(city: str, units: str = "celsius") -> dict:
"""Get current weather for a city."""
return {"temp": 22, "conditions": "sunny"}
client = Dedalus()
runner = DedalusRunner(client)
result = runner.run(
input="What's the weather in Paris?",
model="openai/gpt-4.1",
tools=[get_weather],
)
print(result.final_output)
See Response Schemas for the full ChatCompletion and RunResult
shapes, including tool_calls fields. city: str becomes {"type": "string"}. The more specific the hints, the better the model fills them in.
Write docstrings. The Runner uses your docstring as the tool’s description. The model reads it to decide when to call the function.
Use descriptive names. The model picks which tool to call by name. get_weather beats do_stuff.
Keep tool counts low. Tool schemas take up space in the context window. Minimize the tools you pass for a given task.
Read more
Dedalus Runner
Learn more about the DedalusRunner
MCP Servers
Learn how to connect MCP servers to your Dedalus models
Structured Outputs
Guarantee that your model outputs the desired schema every time
Use Cases
End-to-end examples for inspiration
