Novita Kimi K2 API Agora Suporta Chamada de Funções!

O Kimi K2 representa uma nova era de agentes de IA, combinando desempenho de ponta em domínios especializados com acessibilidade e flexibilidade de código aberto. Com seus 32 bilhões de parâmetros ativados e 1 trilhão de parâmetros totais, o Kimi K2 se destaca por suas forças especializadas em STEM, codificação e uso de ferramentas.

Este artigo explora como a chamada de funções aprimora as capacidades de agente do Kimi K2, o que esse recurso implica e como posiciona o Kimi K2 como líder no futuro dos agentes de IA.

Capacidades de Agente de Código do Kimi K2

1. Proficiência em STEM e Codificação

   • O Kimi K2 alcança desempenho estado da arte (SOTA) em benchmarks de STEM e codificação, incluindo LiveCodeBench e OJBench.
   • Ele pode gerar código complexo, depurar problemas e simular algoritmos intrincados com precisão.

2. Expertise em Uso de Ferramentas

   • O Kimi K2 foi treinado em cenários de uso de ferramentas em múltiplas etapas em centenas de domínios.
   • Sua capacidade de identificar quando uma ferramenta é necessária e executar workflows de múltiplas etapas o torna um assistente de codificação altamente prático.

3. Aprendizagem por Reforço para Execução de Tarefas

   • Ao alavancar autoavaliações baseadas em rubricas e aprendizagem on-policy, o Kimi K2 melhora continuamente seu julgamento e tomada de decisão.

Do Kimi

As Capacidades de Agente do Kimi K2 Dependem da Chamada de Funções

Embora os pontos fortes inerentes do Kimi K2 em codificação e uso de ferramentas sejam impressionantes, suas capacidades de agente dependem fortemente da chamada de funções. Sem esse recurso, sua capacidade de interagir com ferramentas e sistemas externos seria severamente limitada.

O que é Chamada de Funções?

Chamada de funções é um mecanismo estruturado que permite que grandes modelos de linguagem (LLMs) interajam com sistemas, ferramentas ou APIs externas. Em vez de apenas gerar texto, um LLM com suporte a chamada de funções pode analisar prompts do usuário, identificar quando uma ação externa é necessária e gerar chamadas JSON estruturadas para executar funções específicas.

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

Como a Chamada de Funções Funciona

1. Análise do Prompt: O LLM interpreta a solicitação do usuário e determina se uma chamada de função é necessária.
2. Geração da Chamada JSON: Ele gera um objeto JSON estruturado contendo o nome da função e os parâmetros necessários.
3. Execução por Sistemas Externos: Um sistema externo recebe a chamada JSON, executa a função e retorna os resultados.
4. Geração da Resposta: O LLM usa os dados retornados para fornecer uma resposta final ao usuário.

Esse ciclo pode se repetir para tarefas complexas ou de múltiplas etapas, permitindo que o modelo atue como um agente dinâmico e interativo.

Por que a Chamada de Funções é Essencial

• Transforma Conhecimento em Ação: A chamada de funções permite que o Kimi K2 passe de um “provedor de conhecimento” para um “executor de tarefas”.
• Interações com o Mundo Real: Permite que o Kimi K2 interaja com APIs, bancos de dados e sistemas externos, automatizando efetivamente tarefas como agendamento, recuperação de dados e controle de IoT.
• Workflows de Múltiplas Etapas: O Kimi K2 pode encadear várias chamadas de função para executar workflows complexos, como buscar dados, processá-los e armazenar resultados.

Chamada de Funções vs. SDK

Recurso	Chamada de Funções	SDK
Definição	Um mecanismo estruturado para LLMs acionarem funções ou APIs externas.	Um conjunto de ferramentas que simplifica a interação com APIs e sistemas externos.
Propósito	Permite a execução direta de tarefas gerando chamadas de função (ex.: JSON).	Fornece bibliotecas e ferramentas pré-construídas para integração mais fácil de APIs.
Flexibilidade	Altamente dinâmico, permitindo que modelos interajam com qualquer função definida.	Limitado aos recursos e endpoints suportados pelo SDK.
Implementação	Requer definir funções, esquemas e lidar com respostas manualmente.	Abstrai a lógica da API, oferecendo uma experiência plug-and-play.
Caso de Uso	Ideal para automação de tarefas de múltiplas etapas e tomada de decisão em tempo real.	Melhor para desenvolvimento rápido com workflows predefinidos.
Esforço do Desenvolvedor	Requer mais configuração para definir e gerenciar chamadas de função.	Esforço mínimo; simplifica o uso da API com métodos pré-construídos.

O que o Kimi K2 + Chamada de Funções Pode Alcançar?

A combinação dos pontos fortes do Kimi K2 com as capacidades de chamada de funções desbloqueia uma ampla gama de aplicações do mundo real:

1. Execução de Tarefas do Mundo Real

• Automação: Automatize tarefas repetitivas como agendar compromissos, enviar formulários ou gerar relatórios.
• Controle de IoT: Interaja com dispositivos IoT para realizar ações como ajustar a temperatura ambiente ou alternar luzes.

2. Acesso a Dados em Tempo Real

• Atualizações Dinâmicas: Recupere dados em tempo real (ex.: clima, preços de ações) por meio de chamadas de API.
• Respostas Aprimoradas: Integre informações em tempo real nas respostas, melhorando a precisão e relevância.

3. Aplicações Multimodais Avançadas

• Processamento de Imagem e Vídeo: Acione ferramentas externas para tarefas como edição de imagem ou corte de vídeo.
• Integração em Múltiplos Formatos: Processe entradas de texto, imagem e áudio para realizar tarefas complexas.

4. Workflows e Pipelines Complexos

• Encadeie múltiplas chamadas de função para executar pipelines de dados, como:
  • Buscar dados → Analisá-los → Armazenar resultados.
• Permita integração perfeita com bancos de dados e ferramentas de análise para workflows avançados.

5. Soluções Amigáveis ao Desenvolvedor

• APIs Personalizadas: Desenvolvedores podem ajustar o Kimi K2 para interagir com APIs e ferramentas proprietárias.
• Integrações Escaláveis: Adicione facilmente novas funções para expandir as capacidades sem grandes mudanças na infraestrutura.

Uma Demonstração do Kimi K2 com Chamada de Funções

1. Meu orçamento total é de $10.000, que deve cobrir todas as despesas, incluindo transporte, hospedagem e ingressos. Por favor, forneça um detalhamento do orçamento para toda a viagem. Meus critérios principais de avaliação são: conveniência do transporte, disponibilidade de ingressos e qualidade das atrações locais.

2. Por favor, consulte meu orçamento total mencionado acima.

3. Além do meu orçamento total especificado acima, estou procurando uma hospedagem que ofereça uma experiência local autêntica, por isso tenho preferência pelo Airbnb.

4. Verifique meu Google Mail e crie entradas no meu Google Agenda.

Novita Kimi K2 API Suporta Chamada de Funções

Este guia demonstra como usar a Chamada de Funções para recuperar informações meteorológicas atuais para um local especificado pelo usuário. Vamos percorrer um exemplo completo de código Python.

Para o formato específico da API de Chamada de Funções, consulte a Documentação!

Experimente o Kimi K2 Agora!

• Inicializar o Cliente

Primeiro, você precisa inicializar o cliente com sua chave de API Novita.

from openai import OpenAI
import json

client = OpenAI(
    base_url="https://api.novita.ai/v3/openai",
    # Obtenha a chave de API Novita AI em: https://novita.ai/settings/key-management.
    api_key="<YOUR Novita AI API Key>",
)

model = "moonshotai/kimi-k2-instruct"

• Definir a Função a Ser Chamada

Em seguida, defina a função Python que o modelo pode chamar. Neste exemplo, é uma função para obter informações meteorológicas.

# Exemplo de função para simular a busca de dados meteorológicos.
def get_weather(location):
    """Recupera o clima atual para um determinado local."""
    print("Chamando a função get_weather com local: ", location)
    # Em uma aplicação real, você chamaria uma API meteorológica externa aqui.
    # Este é um exemplo simplificado que retorna dados fixos.
    return json.dumps({"location": location, "temperature": "60 degrees Fahrenheit"})

• Construir a Solicitação de API com Ferramentas e Mensagem do Usuário

Agora, crie a solicitação de API para o endpoint Novita. Esta solicitação inclui o parâmetro tools, definindo as funções que o modelo pode usar, e a mensagem do usuário.

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Obtém o clima de um local, o usuário deve fornecer um local primeiro",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "A cidade e estado, ex.: São Francisco, CA",
                    }
                },
                "required": ["location"]
            },
        }
    },
]

messages = [
    {
        "role": "user",
        "content": "Como está o clima em São Francisco?"
    }
]

# Vamos enviar a solicitação e imprimir a resposta.
response = client.chat.completions.create(
    model=model,
    messages=messages,
    tools=tools,
)

# Verifique se a resposta contém chamadas de ferramenta se estiver em produção.
tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.model_dump())

• Saída

{'id': '0', 'function': {'arguments': '{"location": "San Francisco, CA"}', 'name': 'get_weather'}, 'type': 'function'}

• Responder com o Resultado da Chamada de Função e Obter a Resposta Final

O próximo passo é processar a chamada de função, executar a função get_weather e enviar o resultado de volta ao modelo para gerar a resposta final ao usuário.

# Certifique-se de que tool_call está definido a partir da etapa anterior
if tool_call:
    # Estende o histórico da conversa com a mensagem de chamada de ferramenta do assistente
    messages.append(response.choices[0].message)

    function_name = tool_call.function.name
    if function_name == "get_weather":
        function_args = json.loads(tool_call.function.arguments)
        # Executa a função e obtém a resposta
        function_response = get_weather(
            location=function_args.get("location"))
        # Anexa a resposta da função às mensagens
        messages.append(
            {
                "tool_call_id": tool_call.id,
                "role": "tool",
                "content": function_response,
            }
        )

    # Obtém a resposta final do modelo, agora com o resultado da função
    answer_response = client.chat.completions.create(
        model=model,
        messages=messages,
        # Nota: Não inclua o parâmetro tools aqui.
    )
    print(answer_response.choices[0].message)

• Saída

{'id': '0', 'function': {'arguments': '{"location": "San Francisco, CA"}', 'name': 'get_weather'}, 'type': 'function'}

Novita AI Agora Oferece Compatibilidade com o Anthropic SDK

A combinação do Kimi K2 com o Claude Code rapidamente se tornou um tópico quente na comunidade de IA, oferecendo capacidades de agente incomparáveis para aplicações do mundo real. Para tornar essa integração ainda mais perfeita, a Novita AI agora oferece compatibilidade com o Anthropic SDK, permitindo que você aproveite sem esforço o poder do Kimi K2 por meio da interface familiar do Claude Code.

Você pode consultar esta documentação para obter mais detalhes!

1. Instale o Anthropic SDK

pip install anthropic

2. Inicialize o Cliente

Os SDKs do Anthropic são projetados para extrair a chave de API e a URL base das variáveis de ambiente: ANTHROPIC_API_KEY e ANTHROPIC_BASE_URL. Você também pode fornecer os parâmetros ao cliente Anthropic ao inicializá-lo.

Você pode visualizar e gerenciar suas chaves de API na página de configurações.

• Usando Variáveis de Ambiente

export ANTHROPIC_BASE_URL="https://api.novita.ai/anthropic"
export ANTHROPIC_API_KEY="<YOUR_NOVITA_API_KEY>"

• Defina os parâmetros ao inicializar o cliente Anthropic

import anthropic

client = anthropic.Anthropic(
    base_url="https://api.novita.ai/anthropic",
    api_key="<YOUR_NOVITA_API_KEY>"
)

3. Chame a API

import anthropic

# Inicialize o cliente, se você já definiu `ANTHROPIC_BASE_URL` e `ANTHROPIC_API_KEY`
# nas variáveis de ambiente, pode omitir os parâmetros `api_key` e `base_url`.
client = anthropic.Anthropic(
    base_url="https://api.novita.ai/anthropic",
    api_key="<YOUR_NOVITA_API_KEY>"
)

message = client.messages.create(
    model="moonshotai/kimi-k2-instruct",
    max_tokens=1000,
    temperature=1,
    system="Você é um poeta de classe mundial. Responda apenas com poemas curtos.",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Por que o oceano é salgado?"
                }
            ]
        }
    ]
)

print(message.content)

O suporte do Kimi K2 à chamada de funções eleva-o de um LLM de alto desempenho a um agente de IA de próxima geração capaz de interação com o mundo real e execução de tarefas. Quando combinado com seu domínio em STEM e codificação, esse recurso posiciona o Kimi K2 como uma solução econômica e especializada para desenvolver sistemas de IA práticos e dinâmicos.

Ao preencher a lacuna entre conhecimento e ação, o Kimi K2 não apenas melhora a experiência do usuário, mas também democratiza o acesso a capacidades avançadas de IA. Sua natureza de código aberto e acessibilidade o tornam uma força disruptiva no cenário da IA, abrindo caminho para inovação e adoção generalizadas.

Perguntas Frequentes

O que é chamada de funções no contexto de LLMs?

Chamada de funções é 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 chamada de funções?

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.

O Kimi K2 pode substituir modelos proprietários como GPT-4 ou Claude?

O Kimi K2 não tem como objetivo substituir modelos de propósito geral. Em vez disso, ele se concentra em ser um agente especialista com pontos fortes em STEM, codificação e uso de ferramentas, complementado por suas capacidades de chamada de funções.

A Novita AI é a plataforma completa em nuvem que impulsiona suas ambições de IA. APIs integradas, serverless, instância GPU — as ferramentas econômicas que você precisa. Elimine a infraestrutura, comece gratuitamente e torne sua visão de IA realidade.

Leitura Recomendada

• Um Guia para Acessar DeepSeek V3: Localmente e via API
• DeepSeek V3 vs R1: Treinamento em Estágios vs Ciclos Iterativos de SFT-RL
• Executando DeepSeek V3 Localmente: Um Guia do Desenvolvedor