Backend: migrate to pydantic-settings, update Groq model, add env ignores; tests passing; demo verified

Author: austinLorenzMccoy

.gitignore

@@ -121,6 +121,7 @@ celerybeat.pid
 
 # Environments
 .env
+backend/.env
 .venv
 env/
 venv/

README.md

@@ -1,76 +1,68 @@
+# Text-to-SQL Platform (FastAPI + Groq)
 
-# SQL Query Generator with Google Gemini
+This repository provides a modular backend that converts natural language into SQL and executes it on an SQLite database (`student.db`).
 
-This project is a Streamlit application that converts English questions into SQL queries using Google Gemini's generative AI capabilities. It allows users to retrieve data from an SQLite database named **STUDENT**, which contains information about students, their classes, sections, and marks.
+The backend is built with FastAPI and uses Groq’s OpenAI-compatible API to generate SQL from English questions. A separate modern UI will be added by the frontend team.
 
 ## Table of Contents
 
 - [Features](#features)
 - [Technologies Used](#technologies-used)
-- [Installation](#installation)
-- [Usage](#usage)
+- [Getting Started](#getting-started)
 - [Example Queries](#example-queries)
 - [Database Schema](#database-schema)
+- [API Endpoints (v1)](#api-endpoints-v1)
+- [Testing & Coverage](#testing--coverage)
+- [Roadmap](#roadmap)
 - [Contributing](#contributing)
 - [License](#license)
+- [License](#license)
 
 ## Features
 
-- Convert natural language questions into SQL queries.
-- Execute generated SQL queries against an SQLite database.
-- User-friendly interface built with Streamlit.
+- Convert natural language questions into SQL queries (Groq).
+- Execute generated SQL queries against the SQLite database.
+- Clean SQL responses (strip markdown, enforce semicolon).
+- Modern FastAPI backend with auto docs at `/docs`.
+- Full test suite with coverage and temporary DB isolation.
 
 ## Technologies Used
 
-- [Streamlit](https://streamlit.io/) - For building the web application.
-- [SQLite](https://www.sqlite.org/index.html) - Lightweight database to store student records.
-- [Google Generative AI](https://developers.google.com/generative-ai) - To generate SQL queries from text input.
-- [Python](https://www.python.org/) - Programming language used to build the application.
-
-## Installation
-
-To get started, clone the repository and install the required dependencies.
-
-### Prerequisites
-
-- Python 3.7 or higher
-- pip (Python package installer)
-
-### Steps to Install
+- [FastAPI](https://fastapi.tiangolo.com/) for the backend API
+- [Groq](https://groq.com/) for NL→SQL (OpenAI-compatible API)
+- [SQLite](https://www.sqlite.org/) for the demo database
+- [Pydantic](https://docs.pydantic.dev/) for validation
+- [Pytest](https://docs.pytest.org/) for testing and coverage
 
-1. **Clone the repository:**
-   ```bash
-   git clone https://github.com/yourusername/sql-query-generator.git
-   cd sql-query-generator
-   ```
+## Getting Started
 
-2. **Create a virtual environment (optional but recommended):**
-   ```bash
-   python -m venv venv
-   source venv/bin/activate   # On Windows use `venv\Scripts\activate`
-   ```
+Backend is located in `backend/`. You can use Conda for a reproducible setup.
 
-3. **Install required packages:**
-   ```bash
-   pip install -r requirements.txt
-   ```
-
-4. **Set up your environment variables:**
-   - Create a `.env` file in the project root and add your Google API key:
-     ```
-     GOOGLE_API_KEY=your_api_key_here
-     ```
+1) Create environment (Option A: from file)
+```bash
+conda env create -f backend/environment.yml
+conda activate text2sql-backend
+```
 
-## Usage
+Or Option B (manual):
+```bash
+conda create -n text2sql-backend python=3.11 -y
+conda activate text2sql-backend
+pip install -e backend[dev]
+```
 
-1. Run the Streamlit application:
-   ```bash
-   streamlit run app.py
-   ```
+2) Configure environment variables
+```bash
+cp backend/.env.example backend/.env
+# edit backend/.env and set GROQ_API_KEY and (optionally) GROQ_MODEL
+```
 
-2. Open your browser and go to `http://localhost:8501`.
+3) Run the API (from repo root)
+```bash
+uvicorn app.main:app --reload --port 8000 --app-dir backend
+```
 
-3. Input your question in the text box and click the "Ask the question" button. The app will generate an SQL query based on your input and execute it against the database, displaying the results.
+Open API docs at: http://127.0.0.1:8000/docs
 
 ## Example Queries
 
@@ -82,14 +74,49 @@ Here are some example questions you can ask:
 
 ## Database Schema
 
-The database **STUDENT** has the following schema:
+The database **student.db** has the following schema:
 
 | Column  | Type    | Description                          |
 |---------|---------|--------------------------------------|
-| NAME    | TEXT    | Name of the student                  |
-| CLASS   | TEXT    | Class of the student                 |
-| SECTION | TEXT    | Section of the student               |
-| MARKS   | INTEGER | Marks obtained by the student        |
+| NAME    | VARCHAR(25) | Name of the student                  |
+| CLASS   | VARCHAR(25) | Class of the student                 |
+| SECTION | VARCHAR(25) | Section of the student               |
+| MARKS   | INT     | Marks obtained by the student        |
+
+## API Endpoints (v1)
+
+- GET `/api/v1/health` → health check
+- GET `/api/v1/students` → list all students
+- POST `/api/v1/sql` → execute provided SQL
+- POST `/api/v1/nl2sql` → convert NL to SQL using Groq
+
+Example curl (after starting the server):
+```bash
+curl http://127.0.0.1:8000/api/v1/health
+curl http://127.0.0.1:8000/api/v1/students
+curl -X POST http://127.0.0.1:8000/api/v1/sql \
+  -H 'Content-Type: application/json' \
+  -d '{"sql":"SELECT COUNT(*) FROM STUDENT;"}'
+curl -X POST http://127.0.0.1:8000/api/v1/nl2sql \
+  -H 'Content-Type: application/json' \
+  -d '{"question":"How many entries of records are present?"}'
+```
+
+## Testing & Coverage
+
+```bash
+cd backend
+pytest -q --cov=app --cov-report=term-missing
+```
+
+Tests use a temporary SQLite DB and do not touch your real `student.db`.
+
+## Roadmap
+
+- Frontend UI integration (modern SPA)
+- AuthN/Z and rate limiting
+- Schema introspection and multi-table support
+- Safer SQL generation and validation guardrails
 
 ## Contributing
 
@@ -105,23 +132,4 @@ Contributions are welcome! Please open an issue or submit a pull request if you'
 
 This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
 
-```
-
-### Explanation of Sections
-
-1. **Title & Introduction:** Gives an overview of what the project is about.
-2. **Table of Contents:** Helps users navigate the document quickly.
-3. **Features:** Highlights the main features of the app.
-4. **Technologies Used:** Lists the technologies and frameworks involved in the project.
-5. **Installation:** Step-by-step guide on how to install and set up the project.
-6. **Usage:** Instructions on how to run the app and interact with it.
-7. **Example Queries:** Provides sample questions users can input to test the functionality.
-8. **Database Schema:** Describes the structure of the SQLite database.
-9. **Contributing:** Encourages collaboration and outlines how others can contribute to the project.
-10. **License:** States the licensing information for the project.
-
-### Tips for Customization
 
-- Replace placeholders like `yourusername` and `your_api_key_here` with actual values relevant to your project.
-- Adjust the content based on any additional features or changes you have made.
-- Make sure to include any additional documentation or instructions relevant to your specific project needs.

app.py

@@ -0,0 +1,7 @@
+# Copy this file to .env and fill in the values
+APP_NAME=Text-to-SQL Backend
+SQLITE_PATH=../student.db
+
+# Groq settings
+GROQ_API_KEY="your_groq_api_key_here"
+GROQ_MODEL="llama-3.3-70b-versatile"