Chamada de funções e integração com APIs
Domine como orientar LLMs a chamar funções externas ou APIs, permitindo que interajam com sistemas do mundo real.
Chamada de funções e integração com APIs é uma aula grátis de AI Prompt Engineering no CoddyKit. Esta é a aula 1 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Prompt Engineering, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Prompt Engineering inclui 3 aulas no total.
Chamar ferramentas externas
Os LLMs são poderosos, mas vivem principalmente em um mundo de texto. E se precisarem de informações do mundo real ou tiverem de realizar ações?
A chamada de funções permite que os LLMs interajam com ferramentas externas e APIs! Isso preenche a lacuna entre linguagem e ação, permitindo que a IA:
- Obtenha informações atuais (clima, preços de ações)
- Realize ações (envie e-mails, marque compromissos)
- Conecte-se a bancos de dados ou ferramentas personalizadas
Isso abre novas possibilidades para os sistemas de IA.
Papel do LLM: sugerir chamadas
Quando você habilita a chamada de funções, fornece ao LLM descrições das ferramentas disponíveis (funções).
Em vez de responder diretamente, o LLM pode decidir que uma ferramenta seria útil. Em seguida, ele produz uma "sugestão" estruturada de chamada de função, incluindo o nome da função e seus argumentos.
Importante: O LLM não executa a função por conta própria. Ele apenas informa à sua aplicação qual função chamar e com quais entradas.
Definição das suas ferramentas
Para usar a chamada de funções, é necessário definir suas ferramentas (funções) de uma forma que o LLM consiga entender. Normalmente, isso envolve fornecer:
- Um nome para a função (por exemplo,
get_current_weather) - Uma descrição do que ela faz (essencial para que o LLM faça a escolha correta)
- Os parâmetros que ela aceita, incluindo seus tipos e descrições (por exemplo,
location: string)
Esse "esquema" informa ao LLM tudo o que ele precisa saber para sugerir uma chamada válida.
Definição da ferramenta meteorológica
Veja uma definição conceitual em Python para uma ferramenta meteorológica. Observe a descrição e os parâmetros claros. É isso que seria disponibilizado ao LLM.
Essa função representa a ferramenta externa que um LLM conceitualmente "chamaria".
def get_current_weather(location: str, unit: str = "celsius"):
"""
Get the current weather in a given location.
Args:
location (str): The city and state, e.g. "London, UK"
unit (str): The unit of temperature, "celsius" or "fahrenheit"
Returns:
dict: Weather information.
"""
# In a real app, this would call a weather API
if location == "London, UK":
return {"temperature": "15", "unit": unit, "forecast": "cloudy"}
elif location == "New York, USA":
return {"temperature": "20", "unit": unit, "forecast": "sunny"}
else:
return {"temperature": "N/A", "unit": unit, "forecast": "unknown"}
Criação de instruções para ferramentas
Para incentivar o LLM a usar suas ferramentas, sua instrução precisa declarar claramente a intenção do usuário. Em seguida, o LLM decide se uma ferramenta pode ajudar.
Você não informa explicitamente ao LLM "chame get_weather". Em vez disso, faz uma pergunta que deixa isso implícito:
- "Como está o tempo em Londres?"
- "Pode marcar uma reunião para mim amanhã?"
Munido das descrições das ferramentas, o LLM inferirá a necessidade de uma chamada de função.
Sugestão de chamada do LLM
Quando o LLM decide usar uma ferramenta, ele não fornece uma resposta direta. Em vez disso, retorna um objeto estruturado, normalmente em JSON, indicando a função a ser chamada e seus argumentos.
Sua aplicação então analisa essa saída.
Veja o que um LLM poderia sugerir se lhe perguntassem "Como está o tempo em Londres?":
{
"tool_calls": [
{
"id": "call_abc123",
"function": {
"name": "get_current_weather",
"arguments": "{\"location\": \"London, UK\", \"unit\": \"celsius\"}"
},
"type": "function"
}
]
}Sua aplicação executa a ferramenta
Ao receber a sugestão de chamada de função do LLM, sua aplicação assume o controle:
- Ela identifica a função solicitada (por exemplo,
get_current_weather). - Ela extrai os argumentos (por exemplo,
"London, UK"). - Ela executa a função Python real (ou faz a chamada à API) dentro do ambiente da sua aplicação.
É nesse ponto que a ação do "mundo real" acontece fora do LLM.
O LLM processa a saída da ferramenta
Depois que sua aplicação executa a função, ela recebe um resultado (por exemplo, {"temperature": "15", ...}).
Esse resultado é então enviado de volta ao LLM, junto com o histórico original da conversa e a solicitação de chamada de função.
Em seguida, o LLM usa essas novas informações para gerar uma resposta em linguagem natural à consulta original do usuário.
Interação de ponta a ponta
Vamos reunir tudo. Este exemplo mostra o fluxo em que a pergunta de um usuário faz com que um LLM sugira uma chamada de função, sua aplicação a execute e, em seguida, o LLM forneça uma answer final.
Esta é uma representação simplificada do ciclo de interação.
def get_current_weather(location, unit="celsius"):
if location == "London, UK":
return {"temp": "15", "unit": unit, "forecast": "cloudy"}
return {"temp": "N/A", "unit": unit, "forecast": "unknown"}
def simulate_llm_response(user_query):
# LLM 'thinks' and decides to call a tool
if "weather in London" in user_query:
return {
"type": "tool_call",
"function": "get_current_weather",
"args": {"location": "London, UK"}
}
return {"type": "text", "content": "I cannot help with that."}
def simulate_llm_final_response(tool_output):
# LLM processes tool output and gives natural language
temp = tool_output.get("temp", "N/A")
forecast = tool_output.get("forecast", "unknown")
return f"The weather in London is {temp} degrees and {forecast}."
def main():
user_input = "What is the weather in London, UK?"
print(f"User: {user_input}")
llm_output = simulate_llm_response(user_input)
if llm_output["type"] == "tool_call":
func_name = llm_output["function"]
func_args = llm_output["args"]
print(f"LLM suggested calling: {func_name}({func_args})")
# Execute the function
tool_result = get_current_weather(**func_args)
print(f"Tool output: {tool_result}")
# Feed result back to LLM
final_answer = simulate_llm_final_response(tool_result)
print(f"LLM's final answer: {final_answer}")
else:
print(f"LLM: {llm_output['content']}")
if __name__ == "__main__":
main()
Verificação de chamada de função
Imagine que um LLM retorne uma solicitação de chamada de função. Qual é o próximo passo imediato que sua aplicação deve realizar?
Revisão: ferramentas em ação
Nesta lição, exploramos como os LLMs podem interagir com o mundo real por meio da chamada de funções e da integração com APIs.
Aprendemos que:
- Você define ferramentas (funções) com descrições e parâmetros.
- O LLM sugere qual ferramenta chamar e com quais argumentos.
- Sua aplicação executa a ferramenta real e devolve o resultado.
- O LLM então usa o resultado para formular uma answer final e fundamentada.
Essa técnica poderosa permite que os LLMs façam mais do que apenas gerar texto, possibilitando que realizem ações e obtenham informações atualizadas.
Perguntas Frequentes
A aula “Chamada de funções e integração com APIs” é grátis?
Sim — o texto completo de “Chamada de funções e integração com APIs” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Prompt Engineering, atualize para CoddyKit PRO. O curso de AI Prompt Engineering inclui 3 aulas no total.
O que vou aprender em “Chamada de funções e integração com APIs”?
Domine como orientar LLMs a chamar funções externas ou APIs, permitindo que interajam com sistemas do mundo real. Você pratica AI Prompt Engineering com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar AI Prompt Engineering?
Nenhuma experiência prévia é necessária. AI Prompt Engineering no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 3.
Quanto tempo leva a aula “Chamada de funções e integração com APIs”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de AI Prompt Engineering?
Sim. Cada aula de AI Prompt Engineering inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Chamada de funções e integração com APIs
- Sistemas de prompting multiagente
- Ferramentas e plugins personalizados para LLMs