Building a tiny “I Don’t See GPT 5” app sounds like a joke, and yes, the title is meant to make you smile. But the problem it solves is real: developers often try a model name they saw in a tweet or a screenshot and then wonder why their code throws “model not found.” Your users or teammates do the same. An app that checks model availability, explains why a model may not appear, suggests safe fallbacks, and logs what happened is pure gold for day to day developer sanity.
Project Setup Start With A Simple, Reproducible Skeleton
Create a dedicated folder and virtual environment so your machine-wide Python setup stays tidy.
mkdir idontsee-gpt5
cd idontsee-gpt5
python -m venv .venv
source .venv/bin/activate # Windows: .venv\Scripts\activate
pip install fastapi uvicorn streamlit pydantic requests python-dotenv
Create the following structure:
idontsee-gpt5/
app/
__init__.py
config.py
openai_client.py
fallback.py
api.py
ui/
app.py
tests/
test_fallback.py
.env
README.md
Configuration Keep Secrets Out Of Your Code
Place your OpenAI API key in .env:
OPENAI_API_KEY=sk-your-key-here
OPENAI_ORG_ID=optional-if-you-use-one
Write a tiny config helper:
# app/config.py
from dotenv import load_dotenv
import os
load_dotenv()
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")
OPENAI_ORG_ID = os.getenv("OPENAI_ORG_ID", "")
BASE_URL = os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1")
OpenAI Client Ask The Platform, Don’t Guess
The heart of the app is the call that lists models available to your account. The official Python SDK exposes client.models.list() to enumerate models your key can access; you can also call the REST endpoint directly. We’ll use requests here so you can see the raw HTTP clearly, but the same concept applies if you prefer the official SDK. Referencing the official platform docs keeps this future proof.
# app/openai_client.py
import requests
from .config import OPENAI_API_KEY, OPENAI_ORG_ID, BASE_URL
class OpenAIClient:
def __init__(self, api_key: str = OPENAI_API_KEY, org_id: str = OPENAI_ORG_ID):
self.api_key = api_key
self.org_id = org_id
self.base = BASE_URL
def _headers(self):
headers = {
"Authorization": f"Bearer {self.api_key}",
}
if self.org_id:
headers["OpenAI-Organization"] = self.org_id
return headers
def list_models(self):
url = f"{self.base}/models"
r = requests.get(url, headers=self._headers(), timeout=30)
r.raise_for_status()
data = r.json()
# Expect shape: {"data": [{ "id": "gpt-4o", ... }, ... ]}
return [m["id"] for m in data.get("data", [])]
def model_exists(self, model_id: str) -> bool:
return model_id in self.list_models()
Fallback Logic Suggest The Closest Real Option
Users type “gpt-5”, “GPT5”, or “gpt5” because they saw a screenshot somewhere. Your app should calmly translate that intent into a practical model that actually exists for the current API key and then explain what happened. If a “model_not_found” or “not authorized” condition occurs, you return a neat message with alternatives that are visible to the current key. Community threads repeatedly show this is the most common source of confusion; robust handling prevents dead ends.
# app/fallback.py
from difflib import get_close_matches
from typing import List, Tuple
def suggest_fallback(requested: str, available: List[str]) -> Tuple[bool, str, List[str]]:
norm = requested.strip().lower().replace(" ", "").replace("_", "-")
normalized_available = [m.lower() for m in available]
if norm in normalized_available:
exact = available[normalized_available.index(norm)]
return True, exact, []
# Try fuzzy match to suggest near hits
candidates = get_close_matches(norm, normalized_available, n=3, cutoff=0.55)
suggestions = []
for c in candidates:
suggestions.append(available[normalized_available.index(c)])
return False, "", suggestions
FastAPI Backend Build Endpoints For UI And Automation
A minimal FastAPI app exposes two endpoints: one to list all models you can see, and one to check a single requested model with friendly fallback.
# app/api.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from .openai_client import OpenAIClient
from .fallback import suggest_fallback
app = FastAPI(title="I Don't See GPT 5 API", version="1.0.0")
client = OpenAIClient()
class CheckRequest(BaseModel):
model: str
class CheckResponse(BaseModel):
requested: str
found: bool
resolved: str | None
suggestions: list[str]
message: str
@app.get("/models")
def list_models():
try:
return {"models": client.list_models()}
except Exception as e:
raise HTTPException(status_code=502, detail=f"Upstream error: {e}")
@app.post("/check", response_model=CheckResponse)
def check_model(req: CheckRequest):
try:
models = client.list_models()
except Exception as e:
raise HTTPException(status_code=502, detail=f"Cannot list models: {e}")
found, resolved, suggestions = suggest_fallback(req.model, models)
if found:
return CheckResponse(
requested=req.model,
found=True,
resolved=resolved,
suggestions=[],
message=f"Good news: “{req.model}” is available as “{resolved}”."
)
info = "I don’t see that model on this API key. I looked for it and tried to guess what you meant."
if suggestions:
return CheckResponse(
requested=req.model,
found=False,
resolved=None,
suggestions=suggestions,
message=f"{info} Try one of these: {', '.join(suggestions)}."
)
return CheckResponse(
requested=req.model,
found=False,
resolved=None,
suggestions=[],
message=f"{info} No close matches were found. You might need different access or a different model name."
)
Run the backend:
uvicorn app.api:app --reload --port 8080
Make It Friendly And Shareable
A tiny Streamlit page consumes your FastAPI endpoints and gives teammates a no-code way to sanity-check model names.
# ui/app.py
import streamlit as st
import requests
API = "http://localhost:8080"
st.set_page_config(page_title="I Don't See GPT 5", page_icon="👀", layout="centered")
st.title("I Don’t See GPT 5 👀")
st.write("Type a model name. I’ll check your API key’s visibility and suggest safe fallbacks.")
col1, col2 = st.columns([2,1])
with col1:
model = st.text_input("Requested model", value="gpt-5")
with col2:
if st.button("Check"):
try:
r = requests.post(f"{API}/check", json={"model": model}, timeout=30)
r.raise_for_status()
data = r.json()
st.subheader("Result")
st.write(f"**Requested:** {data['requested']}")
st.write(f"**Found:** {data['found']}")
if data["resolved"]:
st.write(f"**Resolved to:** {data['resolved']}")
if data["suggestions"]:
st.write(f"**Suggestions:** {', '.join(data['suggestions'])}")
st.info(data["message"])
except Exception as e:
st.error(f"Error: {e}")
st.subheader("Models You Can See")
if st.button("Refresh list"):
try:
r = requests.get(f"{API}/models", timeout=30)
r.raise_for_status()
models = r.json().get("models", [])
st.write(", ".join(models) if models else "No models returned.")
except Exception as e:
st.error(f"Error: {e}")
Run the UI with:
streamlit run ui/app.pyTesting Prove Your Fallback Works Before Users Do
Create a lightweight test to cover common situations.
# tests/test_fallback.py
from app.fallback import suggest_fallback
def test_exact_match():
found, resolved, suggestions = suggest_fallback("gpt-4o-mini", ["gpt-4o", "gpt-4o-mini"])
assert found and resolved == "gpt-4o-mini" and suggestions == []
def test_close_match():
found, resolved, suggestions = suggest_fallback("gpt5", ["gpt-4o", "gpt-4.1", "gpt-4o-mini"])
assert not found and len(suggestions) >= 1
Run with pytest after pip install pytest.
Security And Reliability Notes Boring But Important
Note On Keys Don’t Paste Secrets In UIs
Load keys from environment variables, never hard-code them or expose them to browsers. Your Streamlit page talks to your FastAPI backend, which holds the key server-side. That way, a front-end user can’t exfiltrate it by opening DevTools.
Note On Rate Limits And Errors Handle The Unhappy Path
APIs return errors and rate limits. Your backend already surfaces upstream failures as 502 with a short message, but you can expand this into structured error codes and retry guidance. Community posts about “model_not_found” and transient visibility issues show these paths are common enough to deserve explicit handling.
Note On Official References Check The Docs When In Doubt
When models change names or capabilities shift, the platform docs are your source of truth and usually the first place to confirm up-to-date behavior. Your app’s design live discovery plus fallback—assumes change and embraces it.
Conclusion
You just learned how to build an “I Don’t See GPT 5” app with Python that converts a common “why does this model not work?” headache into a one-click answer. You built a clean FastAPI backend that checks live availability via the OpenAI API, a Streamlit UI that speaks human, and a fallback module that suggests practical alternatives.