Vector 1
Search, GEO & Knowledge Graphs

How to Build and Deploy an LLM in One Hour

Brian J. Curry
Brian J. Curry
September 13, 2025 · 5 min read

You don’t need a research lab, GPUs, or weeks of effort. With the right tools, you can stand up your own large language model application in about an hour.

Why This Guide Exists

Not long ago, “building with AI” meant million-dollar research budgets and huge teams. Today, a single developer with a laptop can spin up a fully functioning AI assistant in under 60 minutes.

This article walks you through the entire process — from setting up the environment, to wiring in an LLM, to deploying it online. You’ll also see open-source and free options so you don’t get stuck behind a paywall.

By the end, you’ll have:

  • A chatbot that can answer questions from your own documents.
  • An API endpoint that could be integrated into any app.
  • A hosted demo you can share.

The Tech Ingredients

Think of this as a recipe. The main ingredients are:

  • FastAPI → A lightweight web server for your API.
  • Gradio → A plug-and-play chat interface.
  • ChromaDB + SentenceTransformers → A simple vector database for search.
  • An LLM provider → OpenAI, Anthropic, Hugging Face, Groq, Mistral, or even a local Ollama model.

(Image 1 placeholder: A simple diagram showing these components connected — LLM, Vector DB, API, UI. Title it “LLM App Stack.” Place here.)

Step 1: Set Up the Project

Create a folder and basic structure:

mkdir onehour-llm && cd onehour-llm

Project layout:

onehour-llm/
├─ app.py
├─ ingest.py
├─ rag.py
├─ llm_client.py
├─ requirements.txt
├─ .env.example
└─ data/

Step 2: Install Dependencies

Add the following to requirements.txt:

fastapi
uvicorn[standard]
pydantic
python-dotenv
httpx
gradio
chromadb
sentence-transformers

Then install:

python -m venv .venv
source .venv/bin/activate   # Windows: .venv\Scripts\activate
pip install -r requirements.txt

Step 3: Pick Your LLM Provider

This is where flexibility comes in. You’re not locked into one vendor.

Commercial APIs

  • OpenAI → GPT-4o mini is cheap and fast.
  • Anthropic → Claude 3.5 Sonnet for longer, nuanced outputs.
  • Groq → Incredibly fast Llama 3.1 inference.

Free / Open-Source APIs

  • Hugging Face Inference API → Models like Mistral and Llama, with free credits.
  • Together.ai → A hub for community-hosted models.
  • Mistral API → Mistral-7B and Mixtral (Mixture of Experts).
  • Ollama (local) → Run open models directly on your machine.

(Image 2 placeholder: A comparison table — “Provider / Example Model / Cost / Best For.” Place just after this section.)

Step 4: Configure Environment

Create .env.example:

LLM_PROVIDER=openai
LLM_BASE_URL=https://api.openai.com/v1
LLM_API_KEY=YOUR_KEY
LLM_MODEL=gpt-4o-mini
RAG_TOP_K=4

Copy it:

cp .env.example .env

For Anthropic:

LLM_BASE_URL=https://api.anthropic.com/v1
LLM_MODEL=claude-3-5-sonnet

For Grok:

LLM_BASE_URL=https://api.groq.com/openai/v1
LLM_MODEL=llama-3.1-8b-instant

Step 5: LLM Client

llm_client.py

import os, httpx

class LLMClient:
    def __init__(self):
        self.base_url = os.getenv("LLM_BASE_URL").rstrip("/")
        self.api_key = os.getenv("LLM_API_KEY")
        self.model = os.getenv("LLM_MODEL")

    def chat(self, messages, temperature=0.2, max_tokens=800):
        payload = {"model": self.model, "messages": messages,
                   "temperature": temperature, "max_tokens": max_tokens}
        headers = {"Authorization": f"Bearer {self.api_key}",
                   "Content-Type": "application/json"}
        r = httpx.post(f"{self.base_url}/chat/completions",
                       headers=headers, json=payload, timeout=60)
        r.raise_for_status()
        return r.json()["choices"][0]["message"]["content"]

Step 6: Document Ingestion + Retrieval

We’ll keep this lightweight — just text and markdown to start.

rag.py

import os, glob, uuid, chromadb
from chromadb.utils import embedding_functions

MODEL = "sentence-transformers/all-MiniLM-L6-v2"

def get_collection(path="vectorstore", name="docs"):
    client = chromadb.PersistentClient(path=path)
    embed = embedding_functions.SentenceTransformerEmbeddingFunction(model_name=MODEL)
    return client.get_or_create_collection(name=name, embedding_function=embed)

def chunk_text(text, size=800, overlap=120):
    return [text[i:i+size] for i in range(0, len(text), size - overlap)]

def ingest_path(path, collection):
    files = glob.glob(f"{path}/**/*.txt", recursive=True) + glob.glob(f"{path}/**/*.md", recursive=True)
    ids, docs, metas = [], [], []
    for f in files:
        with open(f, "r", encoding="utf-8", errors="ignore") as fh:
            raw = fh.read()
        for i, chunk in enumerate(chunk_text(raw)):
            ids.append(str(uuid.uuid4())); docs.append(chunk); metas.append({"source": f, "chunk": i})
    collection.add(ids=ids, documents=docs, metadatas=metas)
    return len(docs), len(files)

Run:

python ingest.py ./data

(Image 3 placeholder: A visual flow showing “Docs → Chunking → Vector DB → Retrieval → LLM Response.” Place after this code block.)

Step 7: API + UI

app.py

from fastapi import FastAPI
from pydantic import BaseModel
from dotenv import load_dotenv
import gradio as gr
from llm_client import LLMClient
from rag import get_collection, retrieve

load_dotenv()
app, llm, collection = FastAPI(), LLMClient(), get_collection()

SYSTEM_PROMPT = "Answer clearly. Use context when available, and cite sources."

class ChatReq(BaseModel):
    message: str

@app.post("/chat")
def chat(req: ChatReq):
    ctx = retrieve(req.message, collection)
    ctx_text = "\n".join([f"[{i+1}] {c[1]['source']}\n{c[0]}" for i,c in enumerate(ctx)])
    messages = [
        {"role":"system","content":SYSTEM_PROMPT + "\n" + ctx_text},
        {"role":"user","content":req.message}
    ]
    return {"answer": llm.chat(messages)}

def gradio_fn(user_message, history):
    return chat(ChatReq(message=user_message))["answer"]

demo = gr.ChatInterface(fn=gradio_fn, title="One-Hour LLM")
app = gr.mount_gradio_app(app, demo, path="/ui")

Run locally:

uvicorn app:app --host 0.0.0.0 --port 8000

Step 8: Deploy Online

Render (free tier)

  • Push repo to GitHub
  • Create Web Service
  • Build command: pip install -r requirements.txt
  • Start command: uvicorn app:app --host 0.0.0.0 --port $PORT

Hugging Face Spaces

  • Create new Space → type Gradio
  • Upload app.py + requirements.txt
  • Add secrets in Settings → Variables

(Image 4 placeholder: Screenshot mockup of chat UI in Gradio. Place after this section.)

Step 9: Beyond the Hour

Once the basics are working, here are extensions that make it production-ready:

  • More formats → PDFs, HTML, spreadsheets.
  • Vector DB swap → Pinecone, Weaviate, Qdrant.
  • Streaming responses → Feels more natural.
  • Authentication → If you’re sharing outside your team.
  • Observability → Track latency, errors, token usage.

Common Issues & Fixes

  • Slow answers → Try smaller models like llama-3.1-8b-instant.
  • Weird hallucinations → Add “If not in CONTEXT, say you don’t know” to your prompt.
  • Provider errors → Some APIs expect max_output_tokens instead of max_tokens.

Closing Thoughts

In about an hour, you’ve gone from nothing to a working AI assistant:

  • It can answer questions about your documents.
  • It runs behind an API and a simple UI.
  • It’s deployable to the cloud for free.

This workflow is powerful not because it’s complex — but because it’s fast and flexible. You can switch models, swap storage, or extend the features without rewriting everything.

The real magic? You no longer need to wait for big companies to ship tools. You can build your own.

About the author:

Brian Curry is a Kansas City–based Data Scientist, Artificial Intelligence expert and founder of Vector1 Research, a part time passion project, where he explores the frontier of AI, SEO, Machine Learning, Economic Systems, Marketing Modeling, and Econometrics. His work focuses on building intelligent systems that reveal the causal structures driving performance across marketing, content, and economics and the creator of Papilon, an open-source framework for complex system optimization, and Daedalus, a platform for causal and economic analysis.

References

  1. OpenAI. OpenAI API Documentation. Retrieved from https://platform.openai.com/docs
  2. Anthropic. Claude API Reference. Retrieved from https://docs.anthropic.com
  3. Hugging Face. Hugging Face Inference API. Retrieved from https://huggingface.co/inference-api
  4. Groq. Groq API Documentation. Retrieved from https://console.groq.com/docs
  5. Mistral AI. Mistral Models & API. Retrieved from https://mistral.ai
  6. Chroma. ChromaDB Documentation. Retrieved from https://docs.trychroma.com
  7. Gradio. Gradio Documentation. Retrieved from https://www.gradio.app/docs
  8. FastAPI. FastAPI Documentation. Retrieved from https://fastapi.tiangolo.com
  9. Sentence-Transformers. Sentence-Transformers Models. Retrieved from https://www.sbert.net
  10. Render. Render Deployment Guides. Retrieved from https://render.com/docs
  11. Hugging Face Spaces. Spaces Documentation. Retrieved from https://huggingface.co/docs/hub/spaces
  12. Curry, Brian. Research and writing on AI, Data Science, and Complex Systems. Medium: https://medium.com/@brian-curry-research
  13. ChatGPT (OpenAI). Assistance in drafting and structuring this article, including technical instructions and references.

Related research