Building out our tool Creating the API

We previously generated a large set of fake people data with a local LLM and exported it as CSV. In this guide we’ll:

Import that CSV into a local SQLite database.
Scaffold a small FastAPI service that can return fake-person records on demand (for example: “give me 50 fake names, email addresses, ages, etc.”).
Implement a minimal Pydantic request model and a POST endpoint for generating fake data.
Show how to connect FastAPI to SQLite using SQLAlchemy with a dependency-based session.

Here is a portion of the CSV we generated (we will import this into SQLite):

Kara,Jordan,kara.jordan@example.com,28,Dallas,Lawyer
Leo,Nguyen,leo.nguyen@example.com,33,Athens,Teacher
Mia,Thomas,mia.thomas@example.com,30,Syracuse,Journalist
Nina,Harris,nina.harris@example.com,40,Buffalo,Psychologist
Oliver,Garcia,oliver.garcia@example.com,36,Raleigh,Electrician
Paula,Kim,paula.kim@example.com,32,Charlotte,Web Developer
Quinn,Walker,quinn.walker@example.com,29,Denver,Social Worker
Rachel,Perez,rachel.perez@example.com,27,Tucson,Research Scientist
Samuel,Gonzalez,samuel.gonzalez@example.com,44,Minneapolis,Business Consultant
Tina,Martinez,tina.martinez@example.com,30,Kansas City,Physician Assistant
Uma,Lopez,uma.lopez@example.com,31,Oklahoma City,Real Estate Agent
Victor,Rivera,victor.rivera@example.com,37,Cleveland,Dentist
Wendy,Patel,wendy.patel@example.com,28,Salt Lake City,Hospitality Manager
Xavier,Wong,xavier.wong@example.com,39,Fort Worth,Insurance Broker
Yara,Lee,yara.lee@example.com,25,Milwaukee,Automotive Engineer
Alice,Johnson,alice.johnson@example.com,28,San Francisco,Software Developer
Bob,Smith,bob.smith@example.com,34,Austin,Systems Analyst
Charlie,Brown,charlie.brown@example.com,45,New York,Graphic Designer
Diana,Garcia,diana.garcia@example.com,29,Dallas,Marketing Manager
Ethan,Lee,ethan.lee@example.com,31,Miami,Sales Representative
Fiona,Taylor,fiona.taylor@example.com,27,Houston,Business Analyst
George,Jones,george.jones@example.com,40,Seattle,Project Manager
Hannah,Williams,hannah.williams@example.com,22,Boston,Data Scientist

Importing the CSV into SQLite

Open DB Browser for SQLite (or your preferred SQLite client).
Create a new database file (for example fakeData.db).
Use File → Import → Table from CSV and import fake_data.csv.
- If your CSV includes headers, make sure “Column names in the first line” is checked.
Verify the table is populated in Browse Data mode.

A screenshot of DB Browser for SQLite showing a "fake_data" table in Browse Data mode with columns like first_name, last_name, email_address, age, city, and occupation populated with sample rows. The right panel shows a cell editor open for an email address and database/file controls across the top.

After saving and closing DB Browser you should have fakeData.db (or whatever filename you chose) ready to use from your application. Example terminal prompt where the project lives:

(.venv) jeremy@Jeremys-Mac-Studio FakeDataGenerator %

Planning the API

Goal: small Python REST API that returns fake-person data on demand.
Framework: FastAPI — chosen for performance, async support, and automatic interactive docs.
Productivity: GitHub Copilot Chat was used to accelerate scaffolding; remember Copilot is a helper and its suggestions often need manual refinement.

Comparing frameworks (pros/cons) You may compare frameworks quickly to select the right fit. Below is a concise comparison of common choices:

Framework	Pros	Cons
FastAPI	High performance, automatic OpenAPI/docs, async-ready	Requires familiarity with typing/Pydantic
Flask	Lightweight, huge ecosystem, simple for small apps	Less structure for APIs, manual docs
Django REST Framework	Batteries included for complex apps, auth & admin	Heavier, more opinionated, more setup

A dark-themed screenshot of a text/document editor showing bulleted lists comparing "Flask" pros and cons and "Django REST Framework (with Django) Pros," with a visible mouse cursor and a terminal/sidebar on the left.

Project structure (one practical layout for FastAPI)

fastapi-project
  src
    api
      __init__.py
      endpoints/
        router.py
    core/
      config.py
    db/
      database.py
    models/
      __init__.py
    schemas/
      __init__.py
    services/
      __init__.py
    main.py
  tests/
  .env
  requirements.txt
  README.md

A minimal main.py to run the FastAPI app

from fastapi import FastAPI
from api.endpoints.router import router

app = FastAPI()
app.include_router(router)

@app.get("/")
def read_root():
    return {"message": "Welcome to the FastAPI application!"}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

Connecting to SQLite with SQLAlchemy

Use SQLAlchemy to manage the database engine, sessions, and models.
For SQLite, set check_same_thread=False when reusing the engine across threads (typical when using uvicorn in dev).

Example database.py (db layer):

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, declarative_base

DATABASE_URL = "sqlite:///./fakeData.db"  # replace with your DB path

engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

Base = declarative_base()

def get_db():
    """
    Dependency that provides a database session.
    Yields a database session and closes it after use.
    """
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

Designing the endpoint and request model

We’ll accept a POST request that includes a small Pydantic model describing the fake-data request (fields: data_type, count, optional locale).
Initially we used simple deterministic generators (no external Faker dependency) to keep the prototype lightweight and reproducible.

Pydantic request model (models/fake_data_request.py):

from pydantic import BaseModel
from typing import Optional

class FakeDataRequest(BaseModel):
    """
    Request model for fake data generation.

    Attributes:
        data_type (str): Type of fake data to generate (e.g., "name", "email", "phone")
        count (int): Number of records to generate
        locale (str, optional): Locale for data generation (default: "en_US")
    """
    data_type: str
    count: int
    locale: Optional[str] = "en_US"

Router and generators

Keep a single router file to control routing for this small project.
Implement a few simple generators (name, email, phone) without using Faker for now.
Validate data_type against supported generators and return HTTP 400 if unsupported.

Example router (api/endpoints/router.py):

from fastapi import APIRouter, HTTPException
from ..models.fake_data_request import FakeDataRequest
import random
import string

router = APIRouter()

def generate_random_name() -> str:
    first_names = ["John", "Jane", "Michael", "Sarah", "David", "Lisa"]
    last_names = ["Smith", "Johnson", "Williams", "Brown", "Jones", "Garcia"]
    return f"{random.choice(first_names)} {random.choice(last_names)}"

def generate_random_email() -> str:
    domains = ["gmail.com", "yahoo.com", "hotmail.com", "example.com"]
    username = ''.join(random.choices(string.ascii_lowercase, k=8))
    return f"{username}@{random.choice(domains)}"

def generate_random_phone() -> str:
    area_code = random.randint(100, 999)
    prefix = random.randint(100, 999)
    line = random.randint(1000, 9999)
    return f"{area_code}-{prefix}-{line}"

DATA_GENERATORS = {
    "name": generate_random_name,
    "email": generate_random_email,
    "phone": generate_random_phone
}

@router.get("/")
async def read_root():
    """
    Root endpoint that returns a welcome message.
    """
    return {"message": "Welcome to the FastAPI application!"}

@router.post("/getfakedata")
async def generate_fake_data(request: FakeDataRequest) -> dict:
    """
    Generate fake data based on the provided parameters.

    Args:
        request (FakeDataRequest): Request parameters for data generation

    Returns:
        dict: Generated fake data with requested parameters
    """
    try:
        if request.data_type not in DATA_GENERATORS:
            raise HTTPException(
                status_code=400,
                detail=f"Invalid data_type. Supported types: {list(DATA_GENERATORS.keys())}"
            )

        generator = DATA_GENERATORS[request.data_type]
        data = [generator() for _ in range(request.count)]

        return {"data": data}
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

GitHub Copilot can scaffold directories, models, and routes quickly, but expect to refine the output — for example, Copilot suggested integrating Faker; for the prototype we replaced that with simple Python generators to avoid extra dependencies and keep results deterministic during early development.

Running and testing the API

Install dependencies:
- FastAPI, Uvicorn, SQLAlchemy, Pydantic (and others as needed).
- Example: pip install fastapi uvicorn sqlalchemy pydantic
Start the app:

python src/main.py
# or during development with auto-reload:
uvicorn src.main:app --reload --host 0.0.0.0 --port 8000

Expected server log (example):

INFO:     Started server process [83597]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)

Test endpoints with curl, Postman, or the interactive docs at http://localhost:8000/docs. Request validation example

If you POST without a body (or with an invalid body), FastAPI/Pydantic will return a 422 Unprocessable Entity with descriptive errors about the missing or invalid fields.

Example request body to generate three names:

{
  "data_type": "name",
  "count": 3
}

Example successful response (HTTP 200):

{
  "data": [
    "David Williams",
    "Michael Johnson",
    "John Smith"
  ]
}

If you send an unsupported data_type the API returns a 400:

{
  "detail": "Invalid data_type. Supported types: ['name', 'email', 'phone']"
}

Next steps (recommended)

Replace the in-memory generators with DB reads/writes to fakeData.db to return real rows (for example, SELECT random rows or generate variations from DB fields).
Create proper output schemas (Pydantic models) for structured person records.
Add unit and integration tests for endpoints and services.
Expand API docs and examples; FastAPI auto-generates OpenAPI docs at /docs.
Optionally reintroduce Faker for richer, localized fake data—pin dependency versions and validate generated values before production use.

Summary This article demonstrated how to import CSV data into SQLite, scaffold a FastAPI service (with Copilot assistance), implement a POST endpoint backed by a Pydantic model, and test a fake-data generator. The next iteration will wire the generator to the fakeData.db and add structured response schemas, tests, and richer generation strategies. Links and references

FastAPI — https://fastapi.tiangolo.com/
Uvicorn — https://www.uvicorn.org/
SQLAlchemy — https://www.sqlalchemy.org/
Pydantic — https://docs.pydantic.dev/
DB Browser for SQLite — https://sqlitebrowser.org/
Faker (optional) — https://faker.readthedocs.io/en/master/
GitHub Copilot Chat learning resource — https://learn.kodekloud.com/user/courses/github-copilot-in-action

Introduction

GitHub Copilot Basics

Prompt Engineering with Copilot

Advanced Features

Management of GitHub Copilot

Using Copilot Efficiently

Building out our tool Creating the API

Watch Video