W dzisiejszym świecie rozbudowanych aplikacji opartych o LLM (Large Language Models), same modele generujące tekst to za mało. Aby agenci AI byli naprawdę użyteczni, muszą potrafić wchodzić w interakcje z otaczającym ich światem: systemami plików, API czy bazami danych. Do tego właśnie służy wywoływanie narzędzi (tool calling).
W tym artykule przyjrzymy się trzem głównym podejściom do integracji narzędzi z modelami sztucznej inteligencji: Function Calling, protokołowi MCP (Model Context Protocol) oraz natywnym narzędziom we frameworkach takich jak LangChain czy Google Agent Development Kit. Zbadamy ich zalety i podpowiemy, kiedy najlepiej zastosować każde z nich.
1. Function Calling: Niskopoziomowy standard branżowy
Function Calling to mechanizm wbudowany bezpośrednio w natywne interfejsy API dostawców modeli (np. OpenAI, Anthropic, Gemini). Polega on na dostarczeniu modelowi schematu funkcji (najczęściej jako JSON Schema). Model, zamiast zwracać zwykły tekst odpowiedzi, analizuje polecenie i zwraca ustrukturyzowane informacje (nazwę funkcji i jej optymalne parametry). Zasadniczo model mówi aplikacji: "Hej, aby to wykonać, powinieneś uruchomić u siebie tę funkcję z takimi argumentami". Faktyczne wykonanie kodu leży po stronie Twojej aplikacji.
Przykład kodu (OpenAI API w Pythonie):
import json
from openai import OpenAI
client = OpenAI()
# 1. Definicja narzędzia (JSON Schema)
tools = [
{
"type": "function",
"function": {
"name": "get_weather",
"description": "Pobiera aktualną pogodę dla podanego miasta",
"parameters": {
"type": "object",
"properties": {
"location": {"type": "string", "description": "Miasto, np. Warszawa"},
},
"required": ["location"],
},
}
}
]
# 2. Wywołanie modelu
response = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "Jaka jest pogoda w Krakowie?"}],
tools=tools,
tool_choice="auto"
)
# 3. Model decyduje o wywołaniu funkcji i zwraca argumenty
tool_call = response.choices[0].message.tool_calls[0]
print(f"Model chce wywołać funkcję: {tool_call.function.name}")
print(f"Z argumentami: {tool_call.function.arguments}")
# Twoja aplikacja teraz wykonuje logikę pod spodem i zwraca wynik modelowi!
Kluczowe zalety Function Calling:
- Pełna kontrola: Masz całkowitą władzę nad logiką wykonania oraz nad tym, co i w jaki sposób dzieje się w Twoim backendzie.
- Brak zależności trzecich: Integrujesz się bezpośrednio z API dostawcy LLM, nie narzucając sobie konkretnego frameworka dla architektury agenta.
- Elastyczność projektowa: Możesz mapować wywołania LLM na absolutnie wszystko, co tylko da się zapisać przy pomocy kodu aplikacji.
Kiedy wybrać Function Calling?
To idealne rozwiązanie, gdy masz już własną dojrzałą architekturę backendową, zależy Ci na pełnej kontroli i niezależności, a wdrażane przez Ciebie funkcje są bardzo unikalną, specyficzną logiką biznesową, dla której nie warto wdrażać obcych frameworków.
2. MCP (Model Context Protocol): Nowa era standaryzacji
MCP to protokół o otwartym kodzie źródłowym, wprowadzony m.in. przez Anthropic, który zmienia podejście do łączenia asystentów AI z naszymi narzędziami. Zamiast pisać własny ruter i system podpinania pojedynczych funkcji pod konkretny wariant integracji z LLM, uruchamiamy tzw. Serwer MCP, który działa jako pomost pomiędzy modelem AI, a źródłem danych czy narzędziem.
Przykład kodu (Serwer MCP przy użyciu biblioteki FastMCP w Pythonie):
from mcp.server.fastmcp import FastMCP
# Inicjalizacja serwera MCP
mcp = FastMCP("Weather Server")
# Narzędzie udostępniane przez serwer
@mcp.tool()
async def get_weather_by_city(city: str) -> str:
"""Pobiera informacje o pogodzie dla danego miasta"""
# ... tu następuje wywołanie zewnetrznego API pogodowego ...
return f"Pogoda w {city}: Słonecznie, 22°C"
# Uruchomienie serwera stdio - teraz każdy klient MCP (np. Claude Desktop) może się połączyć!
if __name__ == "__main__":
mcp.run()
Kluczowe zalety MCP:
- Raz napisane, używane wszędzie: Jeśli stworzysz serwer MCP dla danego narzędzia, każdy klient/asystent obsługujący MCP (jak Claude Desktop, Cursor AI, czy frameworki AI) natychmiast potrafi z tymi danymi rozmawiać. Bez pisania tzw. "kleju" w kodzie pod klienta.
- Kwestie bezpieczeństwa: Model (klient) prosi o dostęp poprzez ustandaryzowany protokół, a serwer MCP utrzymuje kontrolę nad lokalnymi poświadczeniami i bezpieczeństwem infrastruktury.
Kiedy MCP jest lepsze od Function Callingu?
MCP staje się znacznie lepsze od tradycyjnego Function Calling, gdy chcesz udostępnić te same zaawansowane zasoby wewnątrz firmy (bazy danych, środowiska produkcyjne) dla różnych, niepowiązanych ze sobą aplikacji AI. Stosujesz wtedy jeden, zaufany standard komunikacji zamiast wielokrotnie replikować definicje API dla każdego LLM'a.
3. Natywne Narzędzia z Frameworków (LangChain, LlamaIndex)
Frameworki do budowania agentów AI oferują kompletnie inną – znacznie wyższą – warstwę abstrakcji. Ekosystemy te podchodzą do spraw inaczej: dostarczają potężne pakiety gotowych klas narzędzi („tools”), z których budowę agenta realizuje się z mniejszym nakładem programistycznym.
Przykład kodu (Wbudowane narzędzia w bibliotece LangChain):
from langchain_openai import ChatOpenAI
from langchain.agents import load_tools, initialize_agent, AgentType
llm = ChatOpenAI(temperature=0)
# 1. Ładowanie gotowych narzędzi z frameworka (np. Wikipedia i wyszukiwarka)
tools = load_tools(["wikipedia", "ddg-search"], llm=llm)
# 2. Inicjalizacja agenta bez ręcznego mapowania schematów
agent = initialize_agent(
tools,
llm,
agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
verbose=True
)
# 3. Agent sam orkiestruje wywołania narzędzi krok po kroku!
agent.run("Kto zdobył Oscara za najlepszy film w 2024 roku? Użyj Wikipedii lub wyszukiwarki.")
Kluczowe zalety natywnych narzędzi:
- "Gotowce" zamiast pisania od nowa: Czekają tam na nas setki integracji, np.: Google Search, uruchamianie skryptów Python, środowiska Docker, powiązania z SQL itp.
- Szybkie prototypowanie (Rapid Development): Kod wymagany do podpięcia np. wyszukiwarki zajmuje dwie linijki. Framework sam przetłumaczy definicję dla LLM i wymusi poprawny Function Calling pod spodem warstwy abstrakcji.
- Wbudowana orkiestracja: Od razu pracujesz w architekturze zdolnej do dynamicznego planowania kroków (np. ReAct/Tool Calling Agent). Ekosystem zapewnia pamięć agentowi potrzebną mu do pętli decyzyjnej.
Kiedy natywne narzędzia we frameworkach wypadają najlepiej?
Są poszukiwaną opcją, gdy potrzebujesz bardzo szybkiego wdrożenia zaawansowanego agenta w oparciu o popularne procesy: RAG, web-scraping czy wyszukiwanie w internecie. Wykorzystanie np. LangChain zapobiega odkrywaniu koła na nowo gdy chcemy ułożyć proste "klocki Lego" logicznie ze sobą w całość.
Podsumowanie na szybko:
- Chcesz zbudować solidny, zoptymalizowany kod i masz absolutną kontrolę nad wykonaniem logiki API? Wybierz Function Calling.
- Potrzebujesz standaryzowanej, uniwersalnej metody na wystawienie Twojego lokalnego środowiska lub systemów dla różnorodnych asystentów zewnętrznych (desktopowych i IDE)? Stwórz Serwer MCP.
- Twoim głównym celem jest zbudowanie Agenta korzystającego z gotowych narzędzi (Wikipedia, Scrapery, Bazy Wejktorowe) w kilka minut bez pisania implementacji logiki pętli orkiestracji? Użyj Frameworków takich jak LangChain.