Principais Destaques
Sim ou Não: O modelo Llama 3.2 3B é um modelo de linguagem leve, porém capaz, que suporta chamada de função.
O que ele pode fazer: A chamada de função permite que o modelo interaja com ferramentas externas e APIs, expandindo sua funcionalidade além da geração básica de texto.
Como implementar? Instale APIs através do Novita AI “LLM Playground”, depois implemente com o framework Langchain.
No campo atual da inteligência artificial, muitas pessoas discutem ativamente se o modelo Llama 3.2 3B pode implementar capacidades de chamada de função. Numerosos usuários e desenvolvedores compartilham suas experiências com a chamada de função do Llama 3.2 3B em fóruns e redes sociais. Alguns usuários relatam obter bons resultados com uma taxa de sucesso em torno de 80% ao usar o modelo para chamadas de ferramentas. No entanto, também há relatos de usuários indicando que, em certos casos, o modelo pode interpretar mal o contexto, levando a chamadas de função imprecisas ou falhas. Hoje, vamos nos aprofundar no recurso de chamada de função do Llama 3.2.
O Llama 3.2 Suporta Chamada de Função?
Sim!
Os modelos Llama 3.2, incluindo a variante 3B, suportam chamada de função. Essa capacidade permite que o modelo detecte quando precisa chamar uma função e, em seguida, produza JSON com argumentos para chamar essa função. Essa funcionalidade é uma característica chave da série Llama 3.2, com modelos ajustados para isso. O modelo Llama 3.2 3B é particularmente adequado para aplicações em dispositivos devido ao seu design leve, ainda assim suportando recursos poderosos como chamada de função.
O que é Chamada de Função?
Chamada de função é uma metodologia que permite que LLMs interajam com sistemas externos, APIs e ferramentas. Ao equipar um LLM com um conjunto de funções ou ferramentas, juntamente com detalhes sobre como usá-las, o modelo pode escolher e executar inteligentemente a função apropriada para realizar uma tarefa específica. Essa capacidade estende a funcionalidade dos LLMs além da geração básica de texto, permitindo que eles realizem ações, controlem dispositivos e acessem bancos de dados.
Modelos Suportados para Chamada de Função
Muitos LLMs e plataformas agora suportam chamada de função. Você pode instalar a API através da página “LLM Playground” da Novita AI e implementar chamada de função através do langchain.
- Llama 3.3: A versão de 70 bilhões de parâmetros mostrou forte desempenho em testes de chamada de função, identificando com sucesso quando e quais funções chamar com base nas solicitações dos usuários.
- Mistral: Modelos como Mistral-Large-2 demonstram sucesso em chamada de função em ambientes como watsonx.ai.
- Gemini: Os modelos Gemini do Google também suportam chamada de função com vários exemplos de uso disponíveis.
Se você quiser saber mais informações, veja este site!
fonte do Berkeley Function-Calling Leaderboard
Como Funciona a Chamada de Função?
A chamada de função normalmente envolve um processo de duas etapas:
- Mapear o prompt do usuário para a função correta e parâmetros de entrada. O LLM avalia se alguma ferramenta disponível é relevante para a consulta do usuário.
- Processar a saída da função para gerar uma resposta final coerente. Se aplicável, o LLM constrói uma solicitação formatada para chamar a ferramenta.
- A saída da ferramenta é então analisada e integrada na resposta final.
Aplicações Práticas da Chamada de Função
A chamada de função com o modelo Llama 3.2 3B tem inúmeras aplicações no mundo real:
- Chatbots de Suporte ao Cliente: Automatizar respostas que exigem cálculos ou consulta de informações.
- Processamento de Dados: Interagir com sistemas de back-end para buscar ou atualizar dados.
- Assistentes Virtuais: Melhorar as interações do usuário, permitindo que o assistente execute operações como agendamento ou cálculos.
- Interações com APIs: Converter linguagem natural em chamadas de API.
- Consultas a Bancos de Dados: Criar aplicações que traduzem linguagem natural em consultas válidas a bancos de dados.
- Controle de Casa Inteligente: Controlar dispositivos domésticos inteligentes, definindo temperatura ou alternando luzes usando comandos em linguagem natural.
- Mecanismos de Recuperação de Conhecimento Conversacional: Interagir com bases de conhecimento.
- Plataformas de E-commerce: Fornecer sugestões de produtos em tempo real com base em bancos de dados de inventário, rastrear pedidos ou gerenciar tickets de suporte ao cliente.
- Saúde: Agendar consultas ou recuperar informações de pacientes.
- Viagens: Recuperar informações de voos, reservar reservas ou gerenciar agendamentos.
- Finanças: Fornecer saldos de contas atualizados e processar transações.
Como Usar a Chamada de Função do Llama 3.2 3B via Novita AI
Passo 1: Obter uma Chave de API
Acessando a página “Keys”, você pode copiar a chave de API conforme indicado na imagem.
Ao se registrar, a Novita AI oferece um crédito de $0,5 para você começar!
Se os créditos gratuitos acabarem, você pode pagar para continuar usando.
Passo 2: Usar Langchain para Implementar a Chamada de Função
Vamos criar uma aplicação matemática simples que pode realizar operações de soma e multiplicação.
💡 Embora este guia use LangChain por conveniência, implementar chamada de função não requer nenhum framework específico. O segredo está em projetar os prompts corretos para fazer o modelo entender e invocar funções corretamente. LangChain é usado aqui apenas para simplificar a implementação.
Pré-requisitos
Primeiro, instale os pacotes necessários:
pip install langchain-openai python-dotenv
Configurando o Ambiente
Crie um arquivo .env na raiz do seu projeto e adicione sua chave de API do Novita AI:
NOVITA_API_KEY=sua_chave_api_aqui
Passos de Implementação
1. Definir as Ferramentas
Primeiro, vamos criar duas ferramentas matemáticas simples usando o decorador @tool do LangChain:
from langchain_core.tools import tool
@tool
def multiply(x: float, y: float) -> float:
"""Multiplica dois números."""
return x * y
@tool
def add(x: int, y: int) -> int:
"""Soma dois números."""
return x + y
tools = [multiply, add]
2. Criar a Função de Execução de Ferramentas
Em seguida, implemente uma função para executar as ferramentas:
from typing import Any, Dict, Optional, TypedDict
from langchain_core.runnables import RunnableConfig
class ToolCallRequest(TypedDict):
name: str
arguments: Dict[str, Any]
def invoke_tool(
tool_call_request: ToolCallRequest,
config: Optional[RunnableConfig] = None
):
"""Executa a ferramenta especificada com os argumentos fornecidos."""
tool_name_to_tool = {tool.name: tool for tool in tools}
name = tool_call_request["name"]
requested_tool = tool_name_to_tool[name]
return requested_tool.invoke(tool_call_request["arguments"], config=config)
3. Configurar o Pipeline LangChain
Crie uma cadeia que usa o LLM da Novita AI para selecionar e preparar chamadas de ferramenta:
from langchain_openai import ChatOpenAI
from langchain_core.output_parsers import JsonOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.tools import render_text_description
def create_chain():
"""Cria uma cadeia que usa o modelo LLM especificado para selecionar e preparar chamadas de ferramenta."""
model = ChatOpenAI(
model="meta-llama/llama-3.3-70b-instruct",
api_key=os.getenv("NOVITA_API_KEY"),
base_url="https://api.novita.ai/v3/openai",
)
rendered_tools = render_text_description(tools)
system_prompt = f"""\
Você é um assistente que tem acesso ao seguinte conjunto de ferramentas.
Aqui estão os nomes e descrições de cada ferramenta:
{rendered_tools}
Dada a entrada do usuário, retorne o nome e a entrada da ferramenta a ser usada.
Retorne sua resposta como um JSON com as chaves 'name' e 'arguments'.
O `arguments` deve ser um dicionário, com chaves correspondendo
aos nomes dos argumentos e os valores correspondendo aos valores solicitados.
"""
prompt = ChatPromptTemplate.from_messages(
[("system", system_prompt), ("user", "{input}")]
)
return prompt | model | JsonOutputParser()
4. Criar a Função Principal de Processamento
Implemente a função principal que processa consultas matemáticas:
def process_math_query(query: str):
"""Processa uma consulta matemática usando um LLM para selecionar a ferramenta apropriada e executá-la."""
chain = create_chain()
message = chain.invoke({"input": query})
result = invoke_tool(message, config=None)
return message, result
5. Exemplo de Uso
Veja como usar a implementação:
if __name__ == "__main__":
message, result = process_math_query(
"meta-llama/llama-3.2-3b-instruct",
"quanto é 3 mais 1132"
)
print(result) # Saída: 1135
Problemas Comuns e Solução de Problemas
Os problemas comuns encontrados durante a chamada de função incluem:
- Invocação Incorreta da Função: O modelo pode interpretar mal o contexto, levando à invocação da função errada.
- Alta Latência: Respostas lentas podem ocorrer, potencialmente afetando a experiência do usuário.
- Funções Não Reconhecidas: O modelo pode não reconhecer nomes de funções ou parâmetros válidos, resultando em erros em tempo de execução.
- Alucinações do Modelo: O modelo pode gerar saídas ou parâmetros incorretos, o que pode levar a comportamentos inesperados.
- Passagem Inconsistente de Parâmetros: Parâmetros podem ser passados em formatos inesperados, causando erros durante a execução da função.
- Problemas de Rede: Dependências de API externa podem introduzir latência ou falhas se a conectividade de rede for instável.
- Falhas de Parsing: A saída do modelo pode não estar em conformidade com os formatos esperados (por exemplo, JSON inválido), levando a erros de parsing.
Melhores Práticas para Otimizar a Chamada de Função
Para otimizar a chamada de função:
- Para lidar com Invocação Incorreta da Função: Ajuste o modelo em prompts específicos relacionados à chamada de função para melhorar a compreensão do contexto e minimizar erros na invocação de funções.
- Para mitigar Alta Latência: Otimize os tempos de resposta reduzindo a contagem de tokens nos prompts ou implementando chamadas de função assíncronas para melhor desempenho.
- Para resolver Funções Não Reconhecidas: Antes de invocar funções, valide nomes e parâmetros de funções para garantir que sejam corretamente reconhecidos, evitando assim erros em tempo de execução.
- Para gerenciar Alucinações do Modelo: Implemente estratégias cuidadosas de tratamento de erros para lidar com saídas ou parâmetros incorretos gerados pelo modelo, garantindo que mecanismos de fallback estejam em vigor para resultados inesperados.
- Para garantir Passagem Consistente de Parâmetros: Estabeleça diretrizes claras para formatos de parâmetros e aplique verificações de validação rigorosas para alcançar consistência na forma como os parâmetros são passados durante a execução da função.
- Para lidar com Problemas de Rede: Desenvolva uma estratégia robusta de tratamento de erros para problemas relacionados à rede ao interagir com APIs externas, incluindo mecanismos de repetição para falhas transitórias.
- Para prevenir Falhas de Parsing: Utilize técnicas de validação de saída para garantir que as saídas do modelo estejam em conformidade com os formatos esperados (por exemplo, JSON válido) e implemente tratamento de erros para erros de parsing para manter a estabilidade do sistema.
Em resumo, a capacidade de chamada de função representa um avanço significativo na funcionalidade dos grandes modelos de linguagem, permitindo que eles interajam efetivamente com ferramentas externas e APIs. Embora existam desafios comuns, como invocação incorreta de função, alta latência, funções não reconhecidas e alucinações do modelo, a implementação de melhores práticas e tratamento robusto de erros pode aumentar sua confiabilidade e desempenho. À medida que os desenvolvedores continuam a explorar e refinar esse recurso, as aplicações potenciais em vários domínios provavelmente se expandirão, tornando o Llama 3.2 uma ferramenta versátil para tarefas do mundo real.
Perguntas Frequentes
Por que a chamada de função é crucial para agentes de IA?
Ela permite que agentes de IA realizem tarefas de forma autônoma que exigem dados ou ações externas, aumentando a eficiência em ambientes dinâmicos.
Como a chamada de função melhora o desempenho do LLM?
Ela aumenta a precisão ao permitir recuperação de dados em tempo real, execução de tarefas e tomada de decisão informada por meio de ferramentas externas.
Novita AI é a plataforma tudo-em-um na nuvem que impulsiona suas ambições de IA. APIs integradas, serverless, instância GPU — as ferramentas econômicas que você precisa. Elimine infraestrutura, comece gratuitamente e torne sua visão de IA realidade.
