0Pricing
AI Agents · Leçon

Agents image + texte avec Claude Vision et GPT-4V

Envoyer des images dans des appels d’API, ancrage visuel et utilisation d’outils tenant compte des images.

Agents image + texte avec Claude Vision et GPT-4V est une leçon AI Agents gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Agents, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Agents comprend 4 leçons au total.

Agents multimodaux : images et texte

Un agent multimodal peut voir aussi bien que lire. En envoyant des images avec du texte dans le même appel d'API, l'agent peut répondre à des questions sur des photos, analyser des graphiques, lire des captures d'écran et décrire des diagrammes, le tout dans la même boucle de conversation.

Envoyer des images avec l'API OpenAI

Les modèles de vision d'OpenAI, notamment GPT-4o et GPT-4V, acceptent un tableau content au lieu d'une simple chaîne de caractères. Chaque élément est soit un objet text, soit un objet image_url. L'image peut être une URL publique ou une URL de données encodée 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)

Encoder une image en base64

Pour les images qui ne sont pas accessibles publiquement, comme les fichiers locaux, les captures d'écran ou les fichiers importés par les utilisateurs, encodez-les en base64 et intégrez-les directement à l'appel d'API en utilisant le schéma d'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 Claude Vision

Les modèles Claude d'Anthropic prennent également en charge la vision. Le bloc de contenu utilise un champ source avec type: base64 et media_type. Sa structure diffère légèrement de celle d'OpenAI, mais elle est tout aussi puissante.

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)

Détecter le type MIME à partir de l'extension du fichier

Les différents formats d'image, notamment JPEG, PNG, GIF et WebP, utilisent différents types MIME. Détectez automatiquement le type MIME à partir de l'extension du fichier afin de ne jamais avoir à le coder en dur dans le code de votre agent.

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')

Analyse d'images dans une boucle d'agent

Dans une boucle d'agent, l'analyse d'images est un outil. L'agent décide quand l'appeler, comme pour n'importe quel autre outil. Définissez-le dans le schéma des outils et renvoyez des données structurées, au format JSON, afin que l'agent puisse les exploiter par programmation pour son raisonnement.

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)

Contrôler le niveau de détail des images (OpenAI)

L'API de vision d'OpenAI accepte un paramètre detail : low (rapide, économique, 85 jetons), high (détaillé, l'image est divisée en mosaïque, jusqu'à 1105 jetons) ou auto (le modèle décide). Utilisez low pour les questions simples appelant une réponse oui ou non, et high pour les analyses détaillées, comme la lecture de petits caractères.

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

Conversations avec plusieurs images

Vous pouvez envoyer plusieurs images dans un même message ou au fil des échanges d'une conversation. Cela permet des tâches de comparaison : « Comparez ces deux captures d'écran et décrivez ce qui a changé. »

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

Agent d'analyse d'images : lecteur de captures d'écran

Un cas d'utilisation concret est celui d'un agent qui lit des captures d'écran d'applications pour extraire les valeurs des champs de formulaire, les messages d'erreur ou l'état de l'interface utilisateur. Cette approche est utile pour l'automatisation des tests et le suivi des chaînes de traitement.

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)

Optimiser le coût des appels de vision

Les appels aux API de vision sont nettement plus coûteux que les appels utilisant uniquement du texte. Optimisez les coûts en redimensionnant les images avant leur encodage, car la plupart des modèles acceptent des dimensions de 512×512 à 2048×2048, en utilisant detail=low pour les tâches simples, en mettant en cache les résultats d'analyse des images inchangées et en regroupant plusieurs questions dans un seul appel.

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'

Limites de la vision et solutions de repli

Les modèles de vision ont des limites : ils ne peuvent pas lire de manière fiable des caractères très petits, éprouvent des difficultés avec les images fortement compressées et peuvent inventer des détails. Validez toujours les données extraites essentielles, par exemple les nombres d'un graphique, à l'aide d'une invite de repli demandant des scores de confiance.

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

Vérification des connaissances

Quel paramètre contrôle le niveau de détail et le coût de l'analyse d'image dans l'API de vision d'OpenAI ?

Récapitulatif : agents image-texte

Excellent travail ! Voici ce que vous avez appris :

  • Vision d'OpenAI : tableau content avec des objets image_url et text ; prend en charge les URL et le base64
  • Vision de Claude : source.type: base64 avec media_type
  • Encodage en base64 : lire le fichier → encoder en base64 → intégrer comme URL de données
  • Niveau de détail : utiliser low pour une analyse rapide et économique, et high pour une analyse détaillée
  • Optimisation des coûts : redimensionner les images, regrouper les questions et mettre les résultats en cache

Ensuite : les flux de travail d'agents audio-texte avec la transcription par Whisper et les réponses audio en TTS.

Questions Fréquemment Posées

La leçon « Agents image + texte avec Claude Vision et GPT-4V » est-elle gratuite ?

Oui — le texte complet de « Agents image + texte avec Claude Vision et GPT-4V » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Agents, passe à CoddyKit PRO. Le cours AI Agents comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Agents image + texte avec Claude Vision et GPT-4V » ?

Envoyer des images dans des appels d’API, ancrage visuel et utilisation d’outils tenant compte des images. Tu pratiques AI Agents avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer AI Agents ?

Aucune expérience préalable n'est requise. AI Agents sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Agents image + texte avec Claude Vision et GPT-4V » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon AI Agents ?

Oui. Chaque leçon AI Agents inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Agents image + texte avec Claude Vision et GPT-4V
  2. Flux de travail d’agents audio + texte
  3. Compréhension vidéo par les agents
  4. Schémas de raisonnement multimodal
← Retour à AI Agents