Ao usar a Pydantic para validação de tipo, o JSON Schema para definição estrutural e o gerenciamento adequado de erros, os desenvolvedores podem criar aplicativos robustos que dependem de saídas de IA consistentes e bem formatadas, reduzindo drasticamente a frustração geralmente experimentada ao analisar dados gerados por IA. Qual é o problema com a função Calling Output? Ainda me lembro da primeira vez que tentei construir um sistema de reservas que usou um modelo de IA para analisar pedidos de clientes.O usuário digitaria algo como "Reserve-me uma mesa para quatro às 7 da manhã desta sexta-feira", e a IA deveria extrair os detalhes e passá-los para o nosso sistema de reservas. Foi um desastre! Às vezes, a IA esqueceria campos. Outras vezes, adicionaria outros. Às vezes, devolveria cadeias quando precisávamos de inteiros, ou formataria datas de forma inconsistente. Cada inconsistência significava outro caso de borda a ser tratado, outra if-declaração a ser adicionada, outro relatório de bug dos usuários. O que eu precisava era de uma maneira de garantir que a IA sempre devolvesse exatamente a estrutura que meu sistema esperava. ️ O desafio principal das saídas de função de IA Quando usamos a chamada de função com a IA, estamos essencialmente pedindo ao modelo para agir como um tradutor entre a linguagem humana confusa e os dados estruturados que nossos sistemas podem processar. Isso cria uma tensão fundamental: 
 
 
 Queremos a flexibilidade da entrada de linguagem natural Mas precisamos da rigidez de uma saída de dados consistente A solução está na criação de uma camada de validação que assegura que tudo o que a IA produz é transformado em exatamente o que nossos sistemas esperam. Introdução a Pydantic: The Python Data Validation Hero Pydantic é uma biblioteca de validação de dados que se tornou o padrão para a aplicação de estruturas de dados em aplicações Python.O que o torna perfeito para a chamada de funções é como ele coloca a ponte entre dados dinâmicos, potencialmente confusos e os tipos rigorosos que nossas funções exigem. No seu núcleo, a Pydantic fornece uma maneira simples de definir modelos de dados com anotações de tipo. Quando os dados são passados a esses modelos, a Pydantic valida automaticamente que os dados correspondem aos tipos e formatos esperados. Por exemplo, quando uma IA retorna "4" como uma cadeia para um campo que deveria ser um inteiro, a Pydantic o converte automaticamente. Quando retorna "2023-06-15" para um campo datetime, a Pydantic lida com a análise. Esta coerção automática é o que a torna tão poderosa para lidar com saídas de IA. Como a Pydantic Resolve o Problema de Chamada de Função A principal visão é que podemos usar a Pydantic em dois lugares críticos em nosso fluxo de trabalho de função chamada: 
 
 
 
 
 : We can convert our Pydantic models to JSON Schema that the AI model understands, ensuring the AI knows exactly what format we expect. Definition 
 
 : We can use the same Pydantic models to validate and transform the AI's output, catching any inconsistencies before they reach our business logic. Validation A IA pode ser criativa na compreensão da intenção do usuário, mas a Pydantic garante que a criatividade seja canalizada em uma estrutura consistente com a qual os nossos sistemas podem trabalhar. Eu vi equipes reduzir suas taxas de erro em mais de 90% depois de implementar a validação Pydantic em suas saídas de chamada de função.O que é mais, o tempo de desenvolvimento acelera dramaticamente porque os engenheiros não precisam mais escrever código defensivo em cada passo - eles podem confiar que os dados que chegam às suas funções correspondem às suas expectativas. ️ Construir um quadro confiável para saídas de funções Vamos criar um exemplo completo usando a função de chamada OpenAI com validação Pydantic para garantir saídas sólidas: 
from openai import AzureOpenAI
import json
from pydantic import BaseModel, Field, ValidationError
from typing import Optional, List
from datetime import datetime
from enum import Enum

# Initialize the client
# Initialize the Azure OpenAI client
client = AzureOpenAI(
    api_key="Your key",  
    api_version="2024-10-21",  # Make sure to use a version that supports function calling
    azure_endpoint="Your endpoint"
)

# Define our data structures using Pydantic
class ReservationType(str, Enum):
    DINNER = "dinner"
    LUNCH = "lunch"
    BREAKFAST = "breakfast"

class RestaurantReservation(BaseModel):
    party_size: int = Field(..., gt=0, description="Number of people in the party")
    date: datetime = Field(..., description="Date and time of the reservation")
    special_requests: Optional[str] = Field(None, description="Any special requests")
    reservation_type: ReservationType = Field(..., description="Type of meal")
    customer_name: str = Field(..., min_length=1, description="Name for the reservation")
    phone_number: Optional[str] = Field(None, description="Contact phone number")

# Convert Pydantic model to a JSON schema for the function definition
reservation_schema = RestaurantReservation.model_json_schema()

# Define the function for the AI
functions = [
    {
        "type": "function",
        "function": {
            "name": "make_restaurant_reservation",
            "description": "Make a reservation at a restaurant",
            "parameters": reservation_schema
        }
    }
]

# Function to parse and validate AI output
def parse_reservation_response(response_message):
    # Check if the model wants to call a function
    if not response_message.tool_calls:
        return {"error": "No function call found in response"}
    
    try:
        # Extract the function call arguments
        function_call = response_message.tool_calls[0]
        function_args = json.loads(function_call.function.arguments)
        
        # Validate using Pydantic
        reservation = RestaurantReservation(**function_args)
        
        # If we get here, validation passed
        return reservation.model_dump()
    except ValidationError as e:
        # Detailed validation errors from Pydantic
        return {"error": f"Validation error: {str(e)}"}
    except json.JSONDecodeError:
        return {"error": "Invalid JSON in function arguments"}
    except Exception as e:
        return {"error": f"Unexpected error: {str(e)}"}

# Process user request
def process_reservation_request(user_query):
    try:
        # Get response from the model
        response = client.chat.completions.create(
            model="gpt-4o-mini",  # The name you gave your deployment
            messages=[{"role": "user", "content": user_query}],
            tools=functions,
            tool_choice="auto"
        )
        
        response_message = response.choices[0].message
        
        # Parse and validate the response
        result = parse_reservation_response(response_message)
        
        # Handle errors
        if "error" in result:
            # You might want to retry with a more explicit prompt here
            return {"status": "error", "message": result["error"]}
        
        # Success! We have a valid reservation
        return {
            "status": "success", 
            "reservation": result,
            "confirmation_message": f"Confirmed reservation for {result['party_size']} on {result['date']} under {result['customer_name']}"
        }
        
    except Exception as e:
        return {"status": "error", "message": f"Failed to process request: {str(e)}"}

# Example usage
result = process_reservation_request("I'd like to book a table for 4 people this Friday at 7 PM for dinner. My name is John Smith.")
print(json.dumps(result, indent=2, default=str))
 A saída: função robusta chamando em ação Quando executamos nosso código com a consulta do usuário "Eu gostaria de reservar uma mesa para 4 pessoas nesta sexta-feira às 7 da manhã para jantar sob o nome John Smith", aqui está o que acontece por trás das cenas. Nossa camada de validação Pydantic confirma que todos os campos necessários estão presentes e corretamente digitados, convertendo a cadeia de data em um objeto datetime e garantindo que party_size é um inteiro positivo. A saída final para o usuário é uma mensagem de confirmação: "Confirmada reserva para 4 em 2025-05-09 19:00:00 sob John Smith." Se o usuário tivesse dito algo ambíguo como "Reserve-nos uma tabela em breve", a validação pegaria a data e o nome do cliente faltantes, permitindo-nos solicitar essas peças específicas que faltam em vez de falhar completamente. Por que essa abordagem funciona Existem vários elementos-chave que tornam esta abordagem robusta: 
 
 
 
 
 
 Definições de tipo fortes: modelos pydânticos definem explicitamente quais campos são necessários, seus tipos e restrições, como valores mínimos. Validação automática: Quando criamos um objeto RestauranteReservação, a Pydantic valida automaticamente todos os campos e fornece mensagens de erro detalhadas. Gerenciamento de erros graciosos: capturamos erros de validação e devolvemos informações de erros estruturados em vez de acidentes. Geração de esquemas: os modelos pydanticos podem gerar um esquema JSON que alimentamos diretamente na definição da função, garantindo consistência. Transformação de dados: a Pydantic lida com a conversão de cadeias para datas, enumes para seus tipos corretos e muito mais. Quer usar o Azure OpenAI em vez disso? Se você estiver usando o Azure OpenAI, o padrão é quase idêntico - basta alterar a forma como você inicia o cliente: from openai import AzureOpenAI

# Initialize the Azure OpenAI client
client = AzureOpenAI(
    api_key="your-azure-openai-api-key",  
    api_version="2023-07-01-preview",
    azure_endpoint="https://your-resource-name.openai.azure.com"
)

# The rest of the code remains the same
 Aplicações do mundo real Este padrão não é apenas para reservas de restaurantes. Ele funciona onde quer que você precise de dados estruturados a partir da linguagem natural: 
 
 
 
 
 
 Suporte ao cliente: categorização de ingressos e extração de detalhes-chave Gerenciamento de calendário: Criar reuniões com os participantes e horários corretos Comércio eletrônico: processamento de pesquisas de produtos com filtros e classificação Cuidados de saúde: extraindo sintomas e história médica de descrições de pacientes Finanças: Processamento de descrições de transações em dados categorizados Pensamento Final: a ponte entre o caos e a ordem A chamada de função de IA com validação de saída rigorosa é mais do que um padrão técnico - é a ponte entre o mundo caótico da comunicação humana e o reino ordenado dos sistemas de computador. Ao permitir que os seres humanos se expressem naturalmente, garantindo que os sistemas recebam dados precisamente estruturados, estamos criando interfaces que se sentem humanas, mas funcionam de forma confiável. O futuro pertence a aplicações que podem lidar com a confusão da intenção humana e convertê-la, infalivelmente, em ações que um computador pode executar.

This story contains new, firsthand information uncovered by the writer.

Books authored by me

Esta ferramenta de Python resolveu o caos de chamadas de funções da minha IA

About Author

COMENTARIOS

Rótulos

ESTE ARTIGO FOI APRESENTADO EM

Related Stories

Navegando pelas águas: desenvolvendo aplicações RAG de nível de produção com data lakes

Aumente sua produtividade com estas 18 ferramentas para desenvolvedores 🚀🔥

As camadas invisíveis: por que as entrevistas com usuários são um ativo insubstituível

Navegando pelas águas: desenvolvendo aplicações RAG de nível de produção com data lakes

Aumente sua produtividade com estas 18 ferramentas para desenvolvedores 🚀🔥

As camadas invisíveis: por que as entrevistas com usuários são um ativo insubstituível

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps