Llama 3.3 70B Function Calling: Integração Perfeita para Melhor Desempenho

Principais Destaques

O que faz: Executa recuperação de dados em tempo real, operações do sistema e fluxos de trabalho automatizados.

Quais modelos suportam: Série Llama 3, série GPT, Gemma 2 e Mistral nemo.

Como implementar: Instale APIs através da “Biblioteca de Modelos” da Novita AI, depois implemente com o framework Langchain.

Function calling é uma técnica que melhora significativamente as capacidades dos grandes modelos de linguagem (LLMs), permitindo que eles interajam com o mundo externo. Em vez de apenas gerar texto, os LLMs podem utilizar function calling para executar tarefas específicas, acessar informações em tempo real e realizar operações complexas. Este artigo explorará o conceito de function calling, suas aplicações práticas e como modelos como o Llama 3.3 70B estão tornando-o mais acessível.

Quais Problemas o Function Calling Pode Resolver?

1. Acesso a Informações em Tempo Real

• Verificar preços de ações mais recentes
• Obter dados meteorológicos atuais
• Acessar notícias de última hora

2. Interações com Sistemas

• Enviar e-mails
• Publicar em redes sociais
• Consultar e escrever em bancos de dados

3. Automação de Fluxos de Trabalho

• Coleta e processamento de dados
• Execução de tarefas em várias etapas
• Automação de análises complexas

4. Precisão dos Dados

• Garantir a atualidade das informações
• Fornecer resultados de consulta precisos
• Reduzir erros de dados desatualizados

O que é Function Calling?

Em essência, function calling é a capacidade de um LLM reconhecer quando uma tarefa específica requer uma função ou ferramenta externa e, em seguida, gerar dados estruturados (normalmente em formato JSON) para executar a função. Esses dados estruturados incluem o nome da função e quaisquer argumentos necessários. Basicamente, function calling atua como uma ponte entre o vasto conhecimento da IA e ações tangíveis. Ele capacita agentes de IA ou chatbots a realizar tarefas específicas ou acessar dados e serviços externos.

Modelos Suportados para Function Calling

Muitos LLMs e plataformas agora suportam function calling. Você pode instalar a API através da página “Biblioteca de Modelos” da Novita AI e implementar function calling através do langchain.

• Llama 3.3: A versão de 70 bilhões de parâmetros mostrou forte desempenho em testes de function calling ao identificar com sucesso quando e quais funções chamar com base nas solicitações dos usuários.
  • Llama 3.3 70B
  • Llama 3.1 70B
  • Llama 3.1 8B
• Mistral: Modelos como Mistral-Large-2 demonstram sucesso em function calling em ambientes como watsonx.ai.
  • Mistral Nemo
• Gemini: Os modelos Gemini do Google também suportam function calling com vários exemplos de uso disponíveis.
  • Gemma 2 9B

Como Funciona o Function Calling?

1. Declaração de Função: O processo começa definindo blocos de código reutilizáveis conhecidos como funções, juntamente com descrições de suas capacidades, entradas e saídas.
2. Envio do Prompt: O usuário envia um prompt ao LLM junto com um conjunto de declarações de função. Isso informa ao modelo sobre as ferramentas disponíveis.
3. Análise do Modelo: O LLM analisa o prompt e determina se precisa invocar alguma das funções fornecidas para atender à solicitação.
4. Saída Estruturada: Se uma chamada de função for necessária, o LLM gera uma saída estruturada em formato JSON que inclui o nome da função e valores para seus parâmetros.
5. Invocação da Função: O aplicativo ou sistema usa essa saída estruturada para chamar a função especificada, passando os parâmetros.
6. Execução da Função: O serviço externo ou API executa a função usando os parâmetros fornecidos.
7. Resposta de Saída: O serviço externo envia uma confirmação ou resultado de volta para a IA.
8. Resposta do Modelo: O LLM então usa essa saída para gerar uma resposta em linguagem natural para o usuário ou para processamento adicional.

• Observe que o modelo não chama a função diretamente; em vez disso, sua saída estruturada é usada por um programa externo para fazê-lo.

https://www.youtube.com/watch?v=Qor2VZoBib0

Function Calling vs. Modo JSON

Benefícios do Function Calling

• Maior Eficiência: Chamar funções diretamente leva a tempos de processamento mais rápidos e latência reduzida, crucial para aplicações que exigem ação imediata.
• Flexibilidade Aprimorada: Os desenvolvedores podem facilmente atualizar ou modificar funções sem reformular aplicações inteiras, permitindo ajustes mais rápidos a novos requisitos.
• Escalabilidade: Facilita a escalabilidade ao permitir que novas funções sejam adicionadas sem grandes alterações na infraestrutura existente.
• Interações Personalizadas: Permite experiências de usuário personalizadas; por exemplo, acessar o calendário de um usuário para sugerir horários de reunião que não conflitem com compromissos existentes.
• Unindo IA e Ações do Mundo Real: Permite que a IA realize tarefas práticas como enviar e-mails ou mensagens de texto em nome dos usuários.
• Agentes Conversacionais Complexos: Pode criar chatbots sofisticados que respondem a perguntas complexas usando APIs externas e bases de conhecimento para respostas relevantes.

Aplicações Práticas do Function Calling

• Agentes Conversacionais: Usados em chatbots avançados que utilizam APIs externas para informações atualizadas.
• Compreensão de Linguagem Natural: Extrai dados estruturados de texto para tarefas como reconhecimento de entidades e análise de sentimentos.
• Integração com API: Permite que LLMs se integrem com APIs externas para buscar dados ou executar ações com base na entrada do usuário.
• Assistência Financeira: Constrói consultores financeiros de IA que acessam dados financeiros em tempo real e fornecem conselhos personalizados.
• Automação de Tickets de Suporte: Automatiza a atribuição de tickets de suporte processando tickets usando regras sensíveis ao contexto.
• Recuperação de Conhecimento: Ajuda a recuperar informações de bases de conhecimento criando funções que resumem artigos acadêmicos para responder perguntas e fornecer citações.
• Aplicações Multimodais: Aciona funções com base em imagens, vídeos, áudio e PDFs.

Como Usar o Function Calling do Llama 3.3 70B Através da Novita AI

Passo 1: Obter a Chave da API e Instalá-la!

Acessando a página “Gerenciamento de Chaves”, você pode copiar a chave da API conforme indicado na imagem.

Você pode encontrar a página “Biblioteca de Modelos” da Novita AI. Instale a API da Novita AI usando o gerenciador de pacotes específico da sua linguagem de programação.

Ao se registrar, a Novita AI fornece um crédito de $0,5 para começar!

Se os créditos gratuitos acabarem, você pode pagar para continuar usando.

Passo 2: Usar Langchain para Implementar o Function Calling

Vamos criar uma aplicação matemática simples que pode realizar operações de adição e multiplicação.

💡 Embora este guia use LangChain por conveniência, implementar function calling não requer nenhum framework específico. O segredo está em projetar os prompts certos para fazer o modelo entender e invocar funções corretamente. LangChain é usado aqui simplesmente 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 da API Novita AI:

NOVITA_API_KEY=your_api_key_here

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:
    """Multiply two numbers together."""
    return x * y

@tool
def add(x: int, y: int) -> int:
    """Add two numbers."""
    return x + y

tools = [multiply, add]

2. Criar a Função de Execução das 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
):
    """Execute the specified tool with given arguments."""
    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():
    """Create a chain that uses the specified LLM model to select and prepare tool calls."""
    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"""\
    You are an assistant that has access to the following set of tools. 
    Here are the names and descriptions for each tool:

    {rendered_tools}

    Given the user input, return the name and input of the tool to use. 
    Return your response as a JSON blob with 'name' and 'arguments' keys.

    The `arguments` should be a dictionary, with keys corresponding 
    to the argument names and the values corresponding to the requested values.
    """

    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):
    """Process a mathematical query by using an LLM to select the appropriate tool and execute it."""
    chain = create_chain()
    message = chain.invoke({"input": query})
    result = invoke_tool(message, config=None)
    return message, result

5. Exemplo de Uso

Aqui está como usar a implementação:

if __name__ == "__main__":
    message, result = process_math_query(
        "meta-llama/llama-3.3-70b-instruct", 
        "what's 3 plus 1132"
    )
    print(result)  # Output: 1135

Em conclusão, o function calling está rapidamente transformando a forma como os sistemas de IA interagem com seu ambiente, permitindo aplicações mais práticas, eficientes e amigáveis. Modelos como o Llama 3.3 70B estão abrindo caminho para um acesso mais fácil a essa tecnologia poderosa, abrindo inúmeras possibilidades para o desenvolvimento de IA.

Perguntas Frequentes

O que é function calling no contexto de LLMs?

Function calling é uma técnica que permite que grandes modelos de linguagem reconheçam quando uma tarefa específica requer uma função ou ferramenta externa e gerem dados estruturados para executar essa função.

Quais são os principais benefícios de usar function calling?

Os principais benefícios incluem maior eficiência no processamento de tarefas, flexibilidade aprimorada para desenvolvedores atualizarem funções facilmente, escalabilidade para adicionar novas funcionalidades sem grandes alterações e interações personalizadas com o usuário.

Quais idiomas o Llama 3.3 suporta?

Inglês, Francês, Alemão, Hindi, Italiano, Português, Espanhol e Tailandês

A Novita AI é uma plataforma de nuvem de IA que oferece aos desenvolvedores uma maneira fácil de implantar modelos de IA usando nossa API simples, além de fornecer a nuvem de GPU acessível e confiável para construir e escalar.

Leitura Recomendada

• Como Acessar o Llama 3.3 70b Localmente ou via API: Um Guia Completo
• Revelando os Segredos do Modelo Multilíngue Llama 3.3
• Llama 3.3 70B: Recursos, Guia de Acesso e Comparação de Modelos