​

Provider Comparison for Media Support

​

Overview

• Image format support
• File type compatibility
• Size limits
• Processing speed
• Accuracy and quality
• Cost effectiveness
• Special features

​

Quick Comparison Matrix

​

Image Support

​

Document Support

​

Detailed Provider Profiles

​

OpenAI

• openai/gpt-4o (Recommended for multimodal)
• openai/gpt-4-turbo

• Fast processing (~1-3s per image)
• Excellent general-purpose vision
• Strong multi-image support (up to 10 images)
• Reliable OCR and text extraction
• Good object detection
• Large file support (512 MB for documents)

• Image size limit: 20 MB
• May lack depth on complex reasoning tasks
• Higher cost for vision tasks

• Real-time image analysis
• Multi-image comparisons
• Screenshot debugging
• General image understanding
• Large document processing

• Images: ~$0.0065 per image (1024×1024)
• Text: $0.01 per 1K tokens (input),$0.03 per 1K tokens (output)

payload = {
    "model": "openai/gpt-4o",
    "messages": [
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Analyze this image"},
                {
                    "type": "image_url",
                    "image_url": {"url": "https://example.com/image.jpg"}
                }
            ]
        }
    ],
    "stream": True,
    "max_tokens": 500
}

​

Anthropic (Claude 3)

• anthropic/claude-3-5-sonnet-20241022 (Recommended)
• anthropic/claude-3-opus-20240229 (Highest quality)
• anthropic/claude-3-sonnet-20240229

• Superior reasoning about visual content
• Excellent for document analysis
• Strong at complex visual tasks
• Detailed, thoughtful responses
• Great for academic/research content
• Multi-language support (100+ languages)
• Better at nuanced interpretation

• Image size limit: 5 MB (smaller than competitors)
• Document size limit: 10 MB
• Slightly slower processing
• Higher cost for Opus model

• Legal document review
• Academic paper analysis
• Complex reasoning tasks
• Detailed image interpretation
• Multi-language documents
• Chart and diagram analysis

• Sonnet: $0.003 per image + text tokens
• Opus: $0.015 per image + text tokens

payload = {
    "model": "anthropic/claude-3-5-sonnet-20241022",
    "messages": [
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Provide detailed analysis of this chart with insights"
                },
                {
                    "type": "image_url",
                    "image_url": {"url": "https://example.com/chart.png"}
                }
            ]
        }
    ],
    "stream": True,
    "temperature": 0.3
}

​

Google (Gemini 1.5)

• google/gemini-1.5-pro (Best quality)
• google/gemini-1.5-flash (Best value)

• Massive context window (up to 2 million tokens)
• Can handle very large documents (2GB+)
• Fast processing (Flash variant)
• Excellent multilingual support (100+ languages)
• Strong video frame analysis
• Best price/performance (Flash)
• Can process multiple large PDFs simultaneously

• May be less detailed on complex reasoning
• Beta features may have restrictions

• Large document processing (100+ page PDFs)
• Multi-document analysis
• Video frame extraction and analysis
• High-volume applications
• Cost-sensitive projects
• Research with large datasets

• Flash: Very low cost, ~$0.001 per image
• Pro: Medium cost, ~$0.004 per image

# Process a 200-page PDF
payload = {
    "model": "google/gemini-1.5-pro",
    "messages": [
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Summarize this entire document and extract key findings"
                },
                {
                    "type": "file",
                    "file": {"file_id": "large_document_uuid"}
                }
            ]
        }
    ],
    "stream": True,
    "max_tokens": 2000
}

​

Mistral

• mistral/pixtral-12b

• European data residency
• Privacy-focused
• Good price/performance
• Fast processing
• GDPR compliant
• Lower latency in Europe

• No document (PDF/DOCX) support
• Only text and image inputs
• Smaller model (12B parameters)
• Limited advanced features

• European compliance requirements
• Privacy-sensitive applications
• Cost-effective image analysis
• Basic vision tasks
• Text and image combination

• Low cost, competitive with Flash

payload = {
    "model": "mistral/pixtral-12b",
    "messages": [
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "What objects are in this image?"},
                {
                    "type": "image_url",
                    "image_url": {"url": "https://example.com/photo.jpg"}
                }
            ]
        }
    ],
    "stream": True
}

​

Use Case Recommendations

​

Real-Time Image Analysis

• Fastest processing
• Reliable results
• Good balance of speed and quality

​

Legal Document Review

• Superior reasoning
• Detailed analysis
• Excellent for complex documents

​

Large PDF Processing (100+ pages)

• Massive context window
• Can handle 2GB+ files
• Cost-effective for large docs

​

Multi-Document Analysis

• Best context window
• Can process multiple files
• Maintains context across documents

​

Screenshot Debugging

• Fast turnaround
• Good at UI understanding
• Strong text extraction

​

Chart and Graph Analysis

• Best reasoning
• Detailed insights
• Accurate data interpretation

​

High-Volume Processing

• Lowest cost
• Fast processing
• Good quality for price

​

Privacy-Sensitive Applications

• European data residency
• GDPR compliant
• Privacy-focused

​

Invoice/Receipt Extraction

• Fast and accurate
• Good structured extraction
• Reliable OCR

​

Academic Paper Analysis

• Deep understanding
• Detailed analysis
• Good with technical content

​

Feature Comparison

​

Multi-Image Support

​

Language Support

​

OCR Accuracy

​

Cost Optimization Strategies

​

Choose Based on Task Complexity

# Use Gemini Flash or Mistral
"model": "google/gemini-1.5-flash"  # Cheapest

# Use GPT-4o or Claude Sonnet
"model": "openai/gpt-4o"  # Balanced

# Use Claude Opus
"model": "anthropic/claude-3-opus-20240229"  # Best quality

​

Optimize Input Size

from PIL import Image
import io

def optimize_image(image_path, max_size_mb=5):
    """Resize image to fit under size limit."""
    img = Image.open(image_path)

    # Calculate target size
    current_size = os.path.getsize(image_path) / (1024 * 1024)
    if current_size <= max_size_mb:
        return image_path

    # Reduce quality
    output = io.BytesIO()
    quality = int(85 * (max_size_mb / current_size))
    img.save(output, format='JPEG', quality=quality, optimize=True)

    return output.getvalue()

​

Batch Processing

# Instead of multiple requests
# Send all images in one request (if provider supports)

payload = {
    "model": "google/gemini-1.5-pro",
    "messages": [
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Analyze all these images"},
            ] + [
                {"type": "image_url", "image_url": {"url": url}}
                for url in image_urls
            ]
        }
    ],
    "stream": True
}

​

Performance Benchmarks

​

Average Response Times (Image Analysis)

​

Document Processing (PDF)

​

Choosing the Right Provider

​

Decision Tree

Does your use case involve:

├─ Large documents (100+ pages)?
│  └─ Use: Google Gemini 1.5 Pro
│
├─ Privacy/GDPR requirements?
│  └─ Use: Mistral Pixtral
│
├─ Complex reasoning needed?
│  ├─ Legal/academic?
│  │  └─ Use: Anthropic Claude 3 Opus
│  └─ General analysis?
│     └─ Use: Anthropic Claude 3.5 Sonnet
│
├─ High-volume/cost-sensitive?
│  └─ Use: Google Gemini 1.5 Flash
│
└─ General purpose, fast?
   └─ Use: OpenAI GPT-4o

​

Provider Availability

import requests

def check_provider_availability():
    """Check which providers are currently available."""
    url = "https://api.edenai.run/v3/llm/models"
    headers = {"Authorization": "Bearer YOUR_API_KEY"}

    response = requests.get(url, headers=headers)
    models = response.json()

    multimodal_models = [
        model for model in models.get("data", [])
        if any(cap in model.get("capabilities", [])
               for cap in ["vision", "image", "file"])
    ]

    return multimodal_models

# Usage
available = check_provider_availability()
for model in available:
    print(f"{model['id']}: {model.get('capabilities', [])}")

​

Next Steps

• Working with Media Files - Implementation guide
• Vision Capabilities - Vision features
• File Attachments - Document processing
• Monitor Costs - Track spending
• Chat Completions - Core LLM features