PricingLoginStart free
AI Agents · Lección

Agentes de imagen + texto con Claude Vision y GPT-4V

Envío de imágenes en llamadas a API, fundamentación visual y uso de herramientas conscientes de las imágenes.

Lección 1 de 413 pasos

Agentes de imagen + texto con Claude Vision y GPT-4V es una lección gratuita de AI Agents en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de AI Agents, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de AI Agents incluye 4 lecciones en total.

Agentes multimodales: imágenes + texto

Un agente multimodal puede ver, además de leer. Al enviar imágenes junto con texto en la misma llamada a la API, el agente puede responder preguntas sobre fotografías, analizar gráficos, leer capturas de pantalla y describir diagramas, todo dentro del mismo ciclo de conversación.

Enviar imágenes con la API de OpenAI

Los modelos de visión de OpenAI (GPT-4o, GPT-4V) aceptan un arreglo content en lugar de una cadena simple. Cada elemento es un objeto text o un objeto image_url. La imagen puede ser una URL pública o una URL de datos codificada en base64.

from openai import OpenAI

client = OpenAI(api_key='YOUR_OPENAI_API_KEY')

# Using a public URL
response = client.chat.completions.create(
    model='gpt-4o',
    messages=[
        {
            'role': 'user',
            'content': [
                {
                    'type': 'image_url',
                    'image_url': {
                        'url': 'https://example.com/chart.png'
                    }
                },
                {
                    'type': 'text',
                    'text': 'What trend does this chart show?'
                }
            ]
        }
    ],
    max_tokens=512
)
print(response.choices[0].message.content)

Codificación de imágenes en Base64

Para las imágenes que no son accesibles públicamente (archivos locales, capturas de pantalla o archivos subidos por usuarios), codifíquelas en base64 e insértelas directamente en la llamada a la API mediante el esquema de URL data:image/jpeg;base64,....

import base64
from pathlib import Path

Path('screenshot.png').write_bytes(b'\x89PNG\r\n\x1a\n' + bytes(range(40)))

def encode_image_to_base64(image_path: str) -> str:
    with open(image_path, 'rb') as f:
        return base64.b64encode(f.read()).decode('utf-8')

def build_image_message(image_path: str, question: str, mime: str = 'jpeg') -> dict:
    b64 = encode_image_to_base64(image_path)
    data_url = f'data:image/{mime};base64,{b64}'
    return {
        'role': 'user',
        'content': [
            {'type': 'image_url', 'image_url': {'url': data_url}},
            {'type': 'text', 'text': question}
        ]
    }

message = build_image_message('screenshot.png', 'What error is shown?', mime='png')
print('Message built, image size:', len(message['content'][0]['image_url']['url']))

API de visión de Claude

Los modelos Claude de Anthropic también admiten visión. El bloque de contenido utiliza un campo source con type: base64 y media_type. La estructura es ligeramente diferente de la de OpenAI, pero ofrece la misma potencia.

import anthropic
import base64

client = anthropic.Anthropic(api_key='YOUR_ANTHROPIC_API_KEY')

with open('diagram.png', 'rb') as f:
    image_data = base64.standard_b64encode(f.read()).decode('utf-8')

response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=512,
    messages=[
        {
            'role': 'user',
            'content': [
                {
                    'type': 'image',
                    'source': {
                        'type': 'base64',
                        'media_type': 'image/png',
                        'data': image_data
                    }
                },
                {
                    'type': 'text',
                    'text': 'Describe the architecture shown in this diagram.'
                }
            ]
        }
    ]
)
print(response.content[0].text)

Detectar el tipo MIME a partir de la extensión del archivo

Los distintos formatos de imagen (JPEG, PNG, GIF y WebP) utilizan tipos MIME diferentes. Detecte automáticamente el tipo MIME a partir de la extensión del archivo para no tener que codificarlo de forma fija en el código del agente.

import os
import base64

with open('photo.jpg', 'wb') as f:
    f.write(b'\xff\xd8\xff' + bytes(range(30)))

MIME_MAP = {
    '.jpg': 'image/jpeg',
    '.jpeg': 'image/jpeg',
    '.png': 'image/png',
    '.gif': 'image/gif',
    '.webp': 'image/webp'
}

def get_mime_type(image_path: str) -> str:
    ext = os.path.splitext(image_path)[1].lower()
    mime = MIME_MAP.get(ext)
    if not mime:
        raise ValueError(f'Unsupported image format: {ext}')
    return mime

def load_image_as_base64(image_path: str) -> tuple:
    """Returns (base64_string, mime_type)"""
    mime = get_mime_type(image_path)
    with open(image_path, 'rb') as f:
        b64 = base64.b64encode(f.read()).decode('utf-8')
    return b64, mime

b64, mime = load_image_as_base64('photo.jpg')
print(f'MIME: {mime}, Size: {len(b64)} bytes base64')

Análisis de imágenes en un ciclo de agente

En un ciclo de agente, el análisis de imágenes es una herramienta. El agente decide cuándo invocarla, igual que cualquier otra herramienta. Defínala en el esquema de herramientas y devuelva datos estructurados (JSON) para que el agente pueda razonar sobre ellos mediante código.

def analyze_image_tool(image_path: str, query: str) -> dict:
    """
    Agent tool: analyse an image and return structured findings.
    """
    import anthropic, base64
    client = anthropic.Anthropic(api_key='YOUR_API_KEY')
    b64, mime = load_image_as_base64(image_path)

    structured_query = (
        query + '\n\nRespond with JSON only: '
        '{"description": str, "objects": [str], "text_found": str, "confidence": float}'
    )
    response = client.messages.create(
        model='claude-opus-4-5',
        max_tokens=512,
        messages=[{
            'role': 'user',
            'content': [
                {'type': 'image', 'source': {'type': 'base64',
                  'media_type': mime, 'data': b64}},
                {'type': 'text', 'text': structured_query}
            ]
        }]
    )
    import json
    return json.loads(response.content[0].text)

Controlar el nivel de detalle de las imágenes (OpenAI)

La API de visión de OpenAI acepta un parámetro detail: low (rápido, económico, 85 tokens), high (detallado, divide la imagen en mosaicos, hasta 1105 tokens) o auto (el modelo decide). Utilice low para preguntas sencillas de sí o no y high para análisis minuciosos, como leer texto pequeño.

def query_image_openai(
    image_path: str,
    question: str,
    detail: str = 'auto'  # 'low', 'high', or 'auto'
) -> str:
    import base64
    from openai import OpenAI
    client = OpenAI(api_key='YOUR_OPENAI_API_KEY')
    b64, mime = load_image_as_base64(image_path)
    data_url = f'data:{mime};base64,{b64}'

    response = client.chat.completions.create(
        model='gpt-4o',
        max_tokens=512,
        messages=[{
            'role': 'user',
            'content': [
                {
                    'type': 'image_url',
                    'image_url': {'url': data_url, 'detail': detail}
                },
                {'type': 'text', 'text': question}
            ]
        }]
    )
    return response.choices[0].message.content

Conversaciones con varias imágenes

Puede enviar varias imágenes en un solo mensaje o en distintos turnos de una conversación. Esto permite realizar tareas de comparación: «Compare estas dos capturas de pantalla y describa qué ha cambiado».

def compare_two_images(
    image_path_1: str,
    image_path_2: str,
    comparison_question: str
) -> str:
    import anthropic, base64
    client = anthropic.Anthropic(api_key='YOUR_API_KEY')
    b64_1, mime_1 = load_image_as_base64(image_path_1)
    b64_2, mime_2 = load_image_as_base64(image_path_2)

    response = client.messages.create(
        model='claude-opus-4-5',
        max_tokens=512,
        messages=[{
            'role': 'user',
            'content': [
                {'type': 'image', 'source': {'type': 'base64',
                  'media_type': mime_1, 'data': b64_1}},
                {'type': 'image', 'source': {'type': 'base64',
                  'media_type': mime_2, 'data': b64_2}},
                {'type': 'text', 'text': comparison_question}
            ]
        }]
    )
    return response.content[0].text

Agente de imágenes: lector de capturas de pantalla

Un caso de uso práctico es un agente que lee capturas de pantalla de aplicaciones para extraer valores de campos de formularios, mensajes de error o el estado de la interfaz de usuario. Esto resulta útil para la automatización de pruebas y las canalizaciones de monitorización.

SCREENSHOT_READER_PROMPT = (
    'You are a UI analyser. Given this application screenshot, extract:\n'
    '1. The current page/screen name\n'
    '2. Any error messages\n'
    '3. Key UI elements visible (buttons, form fields, text)\n'
    '4. The overall app state\n\n'
    'Return JSON: {"screen": str, "errors": [str], '
    '"elements": [str], "state": str}'
)

def read_screenshot(screenshot_path: str) -> dict:
    import anthropic, base64, json
    client = anthropic.Anthropic(api_key='YOUR_API_KEY')
    b64, mime = load_image_as_base64(screenshot_path)
    response = client.messages.create(
        model='claude-opus-4-5',
        max_tokens=512,
        messages=[{
            'role': 'user',
            'content': [
                {'type': 'image', 'source': {'type': 'base64',
                  'media_type': mime, 'data': b64}},
                {'type': 'text', 'text': SCREENSHOT_READER_PROMPT}
            ]
        }]
    )
    return json.loads(response.content[0].text)

Optimizar los costes de las llamadas de visión

Las llamadas a las API de visión son considerablemente más caras que las llamadas que solo utilizan texto. Optimice los costes de las siguientes formas: cambie el tamaño de las imágenes antes de codificarlas (la mayoría de los modelos acepta entre 512×512 y 2048×2048), utilice detail=low para tareas sencillas, almacene en caché los resultados del análisis de imágenes que no hayan cambiado y agrupe varias preguntas en una sola llamada.

from PIL import Image
import io, base64

def resize_and_encode(
    image_path: str,
    max_dim: int = 1024
) -> tuple:
    img = Image.open(image_path)
    # Resize maintaining aspect ratio
    ratio = min(max_dim / img.width, max_dim / img.height)
    if ratio < 1.0:
        new_w = int(img.width * ratio)
        new_h = int(img.height * ratio)
        img = img.resize((new_w, new_h), Image.LANCZOS)
        print(f'Resized to {new_w}x{new_h} (from {img.width}x{img.height})')

    # Convert to JPEG for smaller size
    buf = io.BytesIO()
    img.save(buf, format='JPEG', quality=85)
    b64 = base64.b64encode(buf.getvalue()).decode('utf-8')
    return b64, 'image/jpeg'

Limitaciones de la visión y alternativas

Los modelos de visión tienen limitaciones: no pueden leer texto muy pequeño de forma fiable, tienen dificultades con imágenes muy comprimidas y pueden alucinar detalles. Valide siempre los datos extraídos que sean críticos (por ejemplo, los números de los gráficos) con un prompt alternativo que solicite puntuaciones de confianza.

def analyze_with_confidence(
    image_path: str,
    question: str,
    confidence_threshold: float = 0.7
) -> dict:
    import anthropic, json
    client = anthropic.Anthropic(api_key='YOUR_API_KEY')
    b64, mime = load_image_as_base64(image_path)

    prompt = (
        question + '\n\nAlso rate your confidence (0.0-1.0) in the answer.\n'
        'Return JSON: {"answer": str, "confidence": float, '
        '"uncertainty_reason": str}'
    )
    response = client.messages.create(
        model='claude-opus-4-5', max_tokens=256,
        messages=[{'role': 'user', 'content': [
            {'type': 'image', 'source': {'type': 'base64',
              'media_type': mime, 'data': b64}},
            {'type': 'text', 'text': prompt}
        ]}]
    )
    result = json.loads(response.content[0].text)
    if result['confidence'] < confidence_threshold:
        result['action'] = 'human_review_needed'
    return result

Comprobación de conocimientos

¿Qué parámetro controla el nivel de detalle y el coste del análisis de imágenes en la API de visión de OpenAI?

Responde en la lección interactiva

Repaso: agentes de imagen y texto

¡Excelente trabajo! Esto es lo que ha aprendido:

  • Visión de OpenAI: arreglo content con objetos image_url y text; admite URL y base64
  • Visión de Claude: source.type: base64 con media_type
  • Codificación Base64: leer el archivo → codificarlo en base64 → insertarlo como URL de datos
  • Nivel de detalle: utilice low para análisis rápidos y económicos, y high para análisis minuciosos
  • Optimización de costes: cambie el tamaño de las imágenes, agrupe las preguntas y almacene los resultados en caché

A continuación: flujos de trabajo de agentes de audio y texto con transcripción mediante Whisper y respuestas de audio mediante TTS.

Gratis para empezar

Aprende AI Agents con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos
60
Lecciones
239
Empezar a aprender gratisVer el curso completo

Preguntas frecuentes

¿La lección «Agentes de imagen + texto con Claude Vision y GPT-4V» es gratis?

Sí — el texto completo de «Agentes de imagen + texto con Claude Vision y GPT-4V» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de AI Agents, actualiza a CoddyKit PRO. El curso de AI Agents incluye 4 lecciones en total.

¿Qué aprenderé en «Agentes de imagen + texto con Claude Vision y GPT-4V»?

Envío de imágenes en llamadas a API, fundamentación visual y uso de herramientas conscientes de las imágenes. Practicas AI Agents con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar AI Agents?

No se requiere experiencia previa. AI Agents en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Agentes de imagen + texto con Claude Vision y GPT-4V»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de AI Agents?

Sí. Cada lección de AI Agents incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Agentes de imagen + texto con Claude Vision y GPT-4V
  2. Flujos de trabajo de agentes de audio + texto
  3. Comprensión de vídeo en agentes
  4. Patrones de razonamiento entre modalidades
← Volver a AI Agents