A Developer's Guide to the Hugging Face Inference API

import requests
import os

# Best practice: store your token in an environment variable
# For this example, we'll define it directly, but use os.getenv("HF_API_TOKEN") in production.
API_TOKEN = "YOUR_API_TOKEN"
API_URL = "https://api-inference.huggingface.co/models/distilbert/distilbert-base-uncased-finetuned-sst-2-english"

def query_model(payload):
    headers = {"Authorization": f"Bearer {API_TOKEN}"}
    response = requests.post(API_URL, headers=headers, json=payload)
    response.raise_for_status()  # Raise an exception for bad status codes
    return response.json()

# Let's classify a sentence
data_payload = {
    "inputs": "I love the new features in this software, it's amazing!"
}

try:
    output = query_model(data_payload)
    print(output)
    # Expected output might look like: [[{'label': 'POSITIVE', 'score': 0.9998...}]]
except requests.exceptions.RequestException as e:
    print(f"An error occurred: {e}")

import requests

API_URL = "https://api-inference.huggingface.co/models/gpt2"
headers = {"Authorization": "Bearer YOUR_API_TOKEN"}

def query_text_generation(payload):
    response = requests.post(API_URL, headers=headers, json=payload)
    return response.json()

output = query_text_generation({
    "inputs": "The future of AI in software development will be",
    "parameters": {"max_length": 50, "temperature": 0.7}
})
print(output)
# Expected output: [{'generated_text': 'The future of AI in software development will be...'}]

import requests

API_URL = "https://api-inference.huggingface.co/models/google/vit-base-patch16-224"
headers = {"Authorization": "Bearer YOUR_API_TOKEN"}

def query_image_classification(filename):
    with open(filename, "rb") as f:
        data = f.read()
    response = requests.post(API_URL, headers=headers, data=data)
    return response.json()

# Make sure you have an image file (e.g., 'cat.jpg') in the same directory
try:
    output = query_image_classification("cat.jpg")
    print(output)
    # Expected output: [{'score': 0.99..., 'label': 'Egyptian cat'}, {'score': 0.00..., 'label': 'tabby, tabby cat'}, ...]
except FileNotFoundError:
    print("Error: 'cat.jpg' not found. Please provide a valid image file path.")

// Example in JavaScript using fetch
async function queryZeroShot(data) {
    const response = await fetch(
        "https://api-inference.huggingface.co/models/facebook/bart-large-mnli",
        {
            headers: { Authorization: "Bearer YOUR_API_TOKEN" },
            method: "POST",
            body: JSON.stringify(data),
        }
    );
    const result = await response.json();
    return result;
}

queryZeroShot({
    "inputs": "Our new feature launch was a massive success!",
    "parameters": {"candidate_labels": ["marketing", "customer feedback", "technical issue"]}
}).then((response) => {
    console.log(JSON.stringify(response));
    // Expected output: {"sequence": "...", "labels": ["customer feedback", ...], "scores": [0.98..., ...]}
});

# Before: Direct API call to Hugging Face
# This creates a single point of failure.
import requests

HF_API_URL = "https://api-inference.huggingface.co/models/gpt2"
HF_TOKEN = "YOUR_HF_TOKEN"

def direct_hf_call(payload):
    headers = {"Authorization": f"Bearer {HF_TOKEN}"}
    response = requests.post(HF_API_URL, headers=headers, json=payload)
    return response.json()

# After: Calling the unified EvoLink API (OpenAI-compatible)
# Your application is now resilient with automatic failover and load balancing.
import requests

# EvoLink's unified API endpoint (OpenAI-compatible)
EVOLINK_API_URL = "https://api.evolink.ai/v1"
EVOLINK_TOKEN = "YOUR_EVOLINK_TOKEN"

def evolink_image_generation(prompt):
    """
    Generate images using EvoLink's intelligent routing.
    EvoLink automatically routes to the cheapest provider for your chosen model.
    """
    headers = {"Authorization": f"Bearer {EVOLINK_TOKEN}"}

    # Example: Using Seedream 4.0 for story-driven 4K image generation
    payload = {
        'model': 'doubao-seedream-4.0',  # Or 'gpt-4o-image', 'nano-banana'
        'prompt': prompt,
        'size': '1024x1024'
    }

    response = requests.post(f"{EVOLINK_API_URL}/images/generations",
                            headers=headers, json=payload)
    return response.json()

def evolink_video_generation(prompt):
    """
    Generate videos using EvoLink's video models.
    """
    headers = {"Authorization": f"Bearer {EVOLINK_TOKEN}"}

    # Example: Using Sora 2 for 10-second video with audio
    payload = {
        'model': 'sora-2',  # Or 'veo3-fast' for 8-second videos
        'prompt': prompt,
        'duration': 10
    }

    response = requests.post(f"{EVOLINK_API_URL}/videos/generations",
                            headers=headers, json=payload)
    return response.json()