Hugging Face Inference API — Free LLM Hosting Complete Guide 2026

pip install huggingface-hub requests
export HF_TOKEN="hf_your_token_here"

from huggingface_hub import InferenceClient
import os
 
# Token picked up automatically from HF_TOKEN env var
client = InferenceClient(token=os.environ["HF_TOKEN"])
 
# Or pass explicitly
client = InferenceClient(token="hf_your_token_here")

from huggingface_hub import InferenceClient
 
client = InferenceClient()
 
# Mistral 7B — fast and high quality
response = client.text_generation(
    prompt="[INST] Explain the difference between supervised and unsupervised learning. [/INST]",
    model="mistralai/Mistral-7B-Instruct-v0.2",
    max_new_tokens=300,
    temperature=0.7,
    repetition_penalty=1.1,
)
print(response)

# Zephyr 7B — strong instruction following
response = client.text_generation(
    prompt="<|system|>You are a concise technical writer.</s><|user|>What is RAG?</s><|assistant|>",
    model="HuggingFaceH4/zephyr-7b-beta",
    max_new_tokens=200,
)
print(response)

client = InferenceClient()
 
def stream_answer(prompt: str, model: str = "mistralai/Mistral-7B-Instruct-v0.2"):
    full_text = ""
    for token in client.text_generation(
        prompt=f"[INST] {prompt} [/INST]",
        model=model,
        max_new_tokens=500,
        stream=True,
    ):
        print(token, end="", flush=True)
        full_text += token
    print()  # newline after stream
    return full_text
 
answer = stream_answer("Write a Python function that implements binary search.")

# Sentiment classification
result = client.text_classification(
    text="This product exceeded all my expectations!",
    model="distilbert-base-uncased-finetuned-sst-2-english",
)
print(result)
# [ClassificationOutput(label='POSITIVE', score=0.9998)]
 
# Named entity recognition
entities = client.token_classification(
    text="Elon Musk founded SpaceX in Hawthorne, California.",
    model="dslim/bert-base-NER",
)
for entity in entities:
    print(f"{entity['word']}: {entity['entity']}")
 
# Summarization
long_text = """
Transformer models have revolutionized natural language processing. Introduced in
the 2017 paper "Attention Is All You Need," transformers replaced recurrent architectures
with a self-attention mechanism that processes all tokens in parallel. This design enables
training on much larger datasets and produces representations that capture long-range
dependencies more effectively than LSTMs or GRUs.
"""
summary = client.summarization(text=long_text, model="facebook/bart-large-cnn")
print(summary["summary_text"])

from huggingface_hub import InferenceClient
 
class HFChatBot:
    def __init__(self, model: str = "mistralai/Mistral-7B-Instruct-v0.2"):
        self.client = InferenceClient()
        self.model = model
        self.history: list[dict] = []
 
    def _build_prompt(self, user_message: str) -> str:
        """Build Mistral instruction format from conversation history."""
        prompt = ""
        for turn in self.history:
            prompt += f"[INST] {turn['user']} [/INST] {turn['assistant']} </s>"
        prompt += f"[INST] {user_message} [/INST]"
        return prompt
 
    def chat(self, user_message: str) -> str:
        prompt = self._build_prompt(user_message)
        response = self.client.text_generation(
            prompt=prompt,
            model=self.model,
            max_new_tokens=300,
            temperature=0.7,
            stop=["\n[INST]"],
        )
        self.history.append({"user": user_message, "assistant": response.strip()})
        return response.strip()
 
# Usage
bot = HFChatBot()
print(bot.chat("What is gradient descent?"))
print(bot.chat("How does the learning rate affect it?"))

import time
from huggingface_hub import InferenceClient
from huggingface_hub.utils import HfHubHTTPError
 
client = InferenceClient()
 
def generate_with_retry(prompt: str, model: str, max_retries: int = 5) -> str:
    for attempt in range(max_retries):
        try:
            return client.text_generation(
                prompt=prompt,
                model=model,
                max_new_tokens=200,
            )
        except HfHubHTTPError as e:
            if e.response.status_code == 503:
                wait = e.response.json().get("estimated_time", 20)
                print(f"Model loading, waiting {wait:.0f}s... (attempt {attempt + 1})")
                time.sleep(wait + 2)
            else:
                raise
    raise RuntimeError("Model did not become available in time")
 
result = generate_with_retry(
    "[INST] What is Python used for? [/INST]",
    "mistralai/Mistral-7B-Instruct-v0.2",
)
print(result)

from functools import lru_cache
 
client = InferenceClient()
 
@lru_cache(maxsize=500)
def cached_generation(prompt: str, model: str) -> str:
    """Cache identical prompts to avoid redundant API calls."""
    return client.text_generation(
        prompt=prompt,
        model=model,
        max_new_tokens=200,
    )
 
# First call hits API
result = cached_generation("[INST] What is Python? [/INST]", "mistralai/Mistral-7B-Instruct-v0.2")
# Second identical call returns from cache — no API quota used
result = cached_generation("[INST] What is Python? [/INST]", "mistralai/Mistral-7B-Instruct-v0.2")