AI Agents · Aula

Clientes HTTP para agentes: httpx e requests

Requisições HTTP síncronas e assíncronas, gerenciamento de sessões e cabeçalhos.

Aula 1 de 413 etapas

Clientes HTTP para agentes: httpx e requests é uma aula grátis de AI Agents no CoddyKit. Esta é a aula 1 de 4. 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 Agents, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Agents inclui 4 aulas no total.

Por que os clientes HTTP são importantes para agentes

Os agentes de IA frequentemente precisam buscar dados de fontes externas: APIs, sites e serviços. Um cliente HTTP confiável é uma ferramenta essencial no conjunto de recursos de qualquer agente.

O Python tem duas bibliotecas HTTP populares: requests (síncrona e simples) e httpx (compatível com operações síncronas e assíncronas). É essencial compreender quando usar cada uma para criar agentes eficientes.

Solicitação GET básica com requests

A biblioteca requests facilita chamadas HTTP simples. Use requests.get(url) para buscar um recurso e inspecionar a resposta.

Verifique sempre o código de status antes de usar o corpo da resposta, para evitar falhas silenciosas.

import requests

url = 'https://api.example.com/data'
response = requests.get(url)

print(response.status_code)  # 200
print(response.text)         # raw string body
print(response.json())       # parsed JSON dict

Adicionando cabeçalhos e limites de tempo

A maioria das APIs exige cabeçalhos de autenticação. O parâmetro headers= permite passar um dicionário de cabeçalhos. Sempre defina um timeout= para impedir que seu agente fique travado indefinidamente em um servidor lento.

import requests

headers = {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Accept': 'application/json'
}

response = requests.get(
    'https://api.example.com/items',
    headers=headers,
    timeout=10  # seconds
)

data = response.json()
print(data)

raise_for_status() — Falha imediata em caso de erros

response.raise_for_status() gera um HTTPError para códigos de status 4xx e 5xx. Sem ele, uma resposta 404 ou 500 é tratada silenciosamente como sucesso.

Essa é uma prática recomendada para agentes: falhe de forma explícita, para que o agente saiba que deve tentar novamente ou relatar um erro.

import requests

try:
    response = requests.get('https://api.example.com/missing', timeout=10)
    response.raise_for_status()  # raises if status >= 400
    data = response.json()
except requests.HTTPError as e:
    print(f'HTTP error: {e}')
except requests.RequestException as e:
    print(f'Network error: {e}')

Introdução ao httpx

httpx é um cliente HTTP moderno com a mesma API que requests, mas com suporte adicional a operações assíncronas. Ele também impõe limites de tempo por padrão, tornando-o mais seguro para agentes em produção.

Instale-o com pip install httpx. O uso síncrono é quase idêntico ao de requests.

import httpx

response = httpx.get(
    'https://api.example.com/data',
    headers={'Authorization': 'Bearer YOUR_KEY'},
    timeout=10.0
)

response.raise_for_status()
data = response.json()
print(data)

HTTP assíncrono com httpx.AsyncClient

Quando seu agente é executado em um contexto assíncrono (por exemplo, com FastAPI ou asyncio), use httpx.AsyncClient para evitar o bloqueio do loop de eventos. Envolva-o em async with para garantir que a conexão seja fechada corretamente.

import httpx
import asyncio

async def fetch_data(url: str) -> dict:
    async with httpx.AsyncClient(timeout=10.0) as client:
        response = await client.get(
            url,
            headers={'Authorization': 'Bearer YOUR_KEY'}
        )
        response.raise_for_status()
        return response.json()

# result = asyncio.run(fetch_data('https://api.example.com/data'))

Fazendo várias solicitações assíncronas simultaneamente

Uma grande vantagem do HTTP assíncrono é buscar vários URLs ao mesmo tempo com asyncio.gather(). Isso pode acelerar consideravelmente os agentes que precisam de dados de vários endpoints antes de responder.

import httpx
import asyncio

async def fetch_all(urls: list) -> list:
    async with httpx.AsyncClient(timeout=10.0) as client:
        tasks = [client.get(url) for url in urls]
        responses = await asyncio.gather(*tasks)
        return [r.json() for r in responses]

urls = [
    'https://api.example.com/item/1',
    'https://api.example.com/item/2',
    'https://api.example.com/item/3'
]
# results = asyncio.run(fetch_all(urls))

Reutilização de sessões e agrupamento de conexões

Criar uma nova conexão HTTP para cada solicitação é lento. Ambas as bibliotecas são compatíveis com o agrupamento de conexões: requests.Session e httpx.Client reutilizam conexões TCP e compartilham cabeçalhos e cookies entre as solicitações.

Isso é especialmente útil para agentes que fazem muitas chamadas à mesma API.

import httpx

# Create once, reuse for many requests
client = httpx.Client(
    base_url='https://api.example.com',
    headers={'Authorization': 'Bearer YOUR_KEY'},
    timeout=10.0
)

response1 = client.get('/users')
response2 = client.get('/items')
response3 = client.get('/orders')

client.close()  # always close when done

Enviando solicitações POST com corpo JSON

Os agentes frequentemente precisam enviar dados, não apenas lê-los. Use o parâmetro json= para serializar automaticamente um dicionário Python e definir o cabeçalho Content-Type correto.

import httpx

payload = {
    'query': 'latest AI news',
    'max_results': 5,
    'language': 'en'
}

response = httpx.post(
    'https://api.example.com/search',
    json=payload,
    headers={'Authorization': 'Bearer YOUR_KEY'},
    timeout=15.0
)

response.raise_for_status()
results = response.json()
print(results['items'])

Analisando a resposta: texto, json e conteúdo

O objeto de resposta tem três propriedades principais para o corpo:

.text — string decodificada (HTML, XML ou texto simples)
.json() — analisa JSON em um dicionário ou uma lista Python
.content — bytes brutos (para imagens ou arquivos binários)

Use a propriedade apropriada com base no tipo de conteúdo da API.

import httpx

response = httpx.get('https://api.example.com/report', timeout=10.0)

# For JSON APIs
data = response.json()            # dict or list

# For HTML or plain text
html = response.text              # str

# For binary files
image_bytes = response.content    # bytes

print(type(data), type(html), type(image_bytes))

Reunindo tudo: uma ferramenta de busca HTTP para agentes

Aqui está uma função de busca completa e reutilizável que um agente pode chamar como ferramenta. Ela trata os erros adequadamente, registra a solicitação e retorna dados estruturados.

Esse padrão é uma base sólida para qualquer ferramenta de agente que busque dados na web.

import httpx
import logging

logger = logging.getLogger(__name__)

def agent_fetch(url: str, headers: dict = None) -> dict:
    try:
        response = httpx.get(
            url,
            headers=headers or {},
            timeout=10.0
        )
        response.raise_for_status()
        logger.info(f'Fetched {url} -> {response.status_code}')
        return {'success': True, 'data': response.json()}
    except httpx.HTTPStatusError as e:
        return {'success': False, 'error': str(e)}
    except httpx.RequestError as e:
        return {'success': False, 'error': f'Network error: {e}'}

Verificação de conhecimento: clientes HTTP

Teste sua compreensão sobre clientes HTTP para agentes.

Responda na aula interativa

Recapitulação: clientes HTTP para agentes

Nesta lição, você aprendeu a equipar agentes com recursos confiáveis para buscar dados por HTTP:

Use requests para buscas síncronas simples
Use httpx.AsyncClient para solicitações assíncronas sem bloqueio
Sempre defina timeout= e chame raise_for_status()
Reutilize sessões ou clientes para várias chamadas ao mesmo host
Use .json(), .text ou .content com base no tipo de resposta

Uma ferramenta de busca bem escrita é a ponte entre seu agente e a web.

Grátis para começar

Aprenda AI Agents com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 60
Aulas: 239

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Clientes HTTP para agentes: httpx e requests” é grátis?

Sim — o texto completo de “Clientes HTTP para agentes: httpx e requests” é 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 Agents, atualize para CoddyKit PRO. O curso de AI Agents inclui 4 aulas no total.

O que vou aprender em “Clientes HTTP para agentes: httpx e requests”?

Requisições HTTP síncronas e assíncronas, gerenciamento de sessões e cabeçalhos. Você pratica AI Agents 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 Agents?

Nenhuma experiência prévia é necessária. AI Agents 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 4.

Quanto tempo leva a aula “Clientes HTTP para agentes: httpx e requests”?

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 Agents?

Sim. Cada aula de AI Agents 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

Clientes HTTP para agentes: httpx e requests
Analisando HTML com BeautifulSoup
Lidando com paginação e conteúdo dinâmico
Práticas responsáveis de raspagem

← Voltar para AI Agents