Bild vom Autor# Einführung
Daten sind zu einer unverzichtbaren Ressource für jedes erfolgreiche Unternehmen geworden, da sie wertvolle Erkenntnisse für eine fundierte Entscheidungsfindung liefern. Angesichts der Bedeutung von Daten bauen viele Unternehmen Systeme zur Speicherung und Analyse dieser Daten auf. Allerdings kommt es oft vor, dass es schwierig ist, die notwendigen Daten zu erfassen und zu analysieren, insbesondere angesichts der zunehmenden Komplexität des Datensystems.
Mit dem Aufkommen der generativen KI ist die Datenverarbeitung erheblich einfacher geworden, da wir jetzt einfache natürliche Sprache verwenden können, um eine weitgehend genaue Ausgabe zu erhalten, die der von uns bereitgestellten Eingabe genau entspricht. Es ist auch auf die Datenverarbeitung und -analyse mit SQL anwendbar, wo wir die Entwicklung von Abfragen anfordern können.
In diesem Artikel entwickeln wir eine einfache API-Anwendung, die natürliche Sprache in SQL-Abfragen übersetzt, die unsere Datenbank versteht. Wir werden drei Hauptwerkzeuge verwenden: OpenAI, FastAPIUnd SQLite.
Hier ist der Plan.
# Entwicklung von Textual content-to-SQL-Apps
Zunächst bereiten wir alles vor, was wir für unser Projekt benötigen. Alles, was Sie angeben müssen, ist die OpenAI-API-Schlüsselmit dem wir auf das generative Modell zugreifen. Um die Anwendung zu containerisieren, verwenden wir Dockerdie Sie für die lokale Implementierung mit erwerben können Docker-Desktop.
Andere Komponenten wie SQLite sind bereits bei der Set up von Python verfügbar und FastAPI wird später installiert.
Für die Gesamtprojektstruktur verwenden wir Folgendes:
text_to_sql_app/
├── app/
│ ├── __init__.py
│ ├── database.py
│ ├── openai_utils.py
│ └── predominant.py
├── demo.db
├── init_db.sql
├── necessities.txt
├── Dockerfile
├── docker-compose.yml
├── .envErstellen Sie die Struktur wie oben, oder verwenden Sie Folgendes Repository um die Dinge einfacher zu machen. Wir werden weiterhin jede Datei durchgehen, um zu verstehen, wie die Anwendung entwickelt wird.
Beginnen wir mit dem Auffüllen der .env Datei mit dem OpenAI-API-Schlüssel, den wir zuvor erworben haben. Das können Sie mit dem folgenden Code machen:
OPENAI_API_KEY=YOUR-API-KEYDann gehen Sie zu necessities.txt um die notwendigen Bibliotheken auszufüllen, die wir verwenden werden
fastapi
uvicorn
sqlalchemy
openai
pydantic
python-dotenvAls nächstes gehen wir weiter zum __init__.py Datei, und wir werden den folgenden Code einfügen:
from pathlib import Path
from dotenv import load_dotenv
load_dotenv(dotenv_path=Path(__file__).resolve().mum or dad.mum or dad / ".env", override=False)Der obige Code stellt sicher, dass die Umgebung alle notwendigen Schlüssel enthält, die wir benötigen.
Dann werden wir Python-Code entwickeln database.py Datei zum Herstellen einer Verbindung mit der SQLite-Datenbank, die wir später erstellen werden (genanntdemo.db) und bieten eine Möglichkeit zum Ausführen von SQL-Abfragen.
from sqlalchemy import create_engine, textual content
from sqlalchemy.orm import Session
ENGINE = create_engine("sqlite:///demo.db", future=True, echo=False)
def run_query(sql: str) -> checklist(dict):
with Session(ENGINE) as session:
rows = session.execute(textual content(sql)).mappings().all()
return (dict(r) for r in rows)Danach bereiten wir die vor openai_utils.py Datei, die das Datenbankschema und die Eingabefragen akzeptiert. Die Ausgabe erfolgt im JSON-Format und enthält die SQL-Abfrage (mit einem Schutz, der Schreibvorgänge verhindert).
import os
import json
from openai import OpenAI
consumer = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
_SYSTEM_PROMPT = """
You exchange natural-language questions into read-only SQLite SQL.
By no means output INSERT / UPDATE / DELETE.
Return JSON: { "sql": "..." }.
"""
def text_to_sql(query: str, schema: str) -> str:
response = consumer.chat.completions.create(
mannequin="gpt-4o-mini",
temperature=0.1,
response_format={"kind": "json_object"},
messages=(
{"function": "system", "content material": _SYSTEM_PROMPT},
{"function": "consumer",
"content material": f"schema:n{schema}nnquestion: {query}"}
)
)
payload = json.hundreds(response.selections(0).message.content material)
return payload("sql")Wenn sowohl der Code als auch die Verbindung bereit sind, bereiten wir die Anwendung mithilfe von FastAPI vor. Die Anwendung akzeptiert Fragen in natürlicher Sprache und das Datenbankschema und konvertiert sie in SQL SELECT Abfragen durchführen, sie über die SQLite-Datenbank ausführen und die Ergebnisse als JSON zurückgeben. Bei der Anwendung handelt es sich um eine API, auf die wir über die CLI zugreifen können.
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from sqlalchemy import examine
from .database import ENGINE, run_query
from .openai_utils import text_to_sql
app = FastAPI(title="Textual content-to-SQL Demo")
class NLRequest(BaseModel):
query: str
@app.on_event("startup")
def capture_schema() -> None:
insp = examine(ENGINE)
international SCHEMA_STR
SCHEMA_STR = "n".be part of(
f"CREATE TABLE {t} ({', '.be part of(c('identify') for c in insp.get_columns
for t in insp.get_table_names()
)
@app.publish("/question")
def question(req: NLRequest):
strive:
sql = text_to_sql(req.query, SCHEMA_STR)
if not sql.lstrip().decrease().startswith("choose"):
elevate ValueError("Solely SELECT statements are allowed")
return {"sql": sql, "end result": run_query(sql)}
besides Exception as e:
elevate HTTPException(status_code=400, element=str(e))Das ist alles, was wir für die Hauptanwendung benötigen. Als nächstes bereiten wir die Datenbank vor. Nutzen Sie die Datenbank unten im init_db.sql B. für Zwecke, aber Sie können es jederzeit ändern, wenn Sie möchten.
DROP TABLE IF EXISTS order_items;
DROP TABLE IF EXISTS orders;
DROP TABLE IF EXISTS funds;
DROP TABLE IF EXISTS merchandise;
DROP TABLE IF EXISTS clients;
CREATE TABLE clients (
id INTEGER PRIMARY KEY,
identify TEXT NOT NULL,
nation TEXT,
signup_date DATE
);
CREATE TABLE merchandise (
id INTEGER PRIMARY KEY,
identify TEXT NOT NULL,
class TEXT,
value REAL
);
CREATE TABLE orders (
id INTEGER PRIMARY KEY,
customer_id INTEGER,
order_date DATE,
whole REAL,
FOREIGN KEY (customer_id) REFERENCES clients(id)
);
CREATE TABLE order_items (
order_id INTEGER,
product_id INTEGER,
amount INTEGER,
unit_price REAL,
PRIMARY KEY (order_id, product_id),
FOREIGN KEY (order_id) REFERENCES orders(id),
FOREIGN KEY (product_id) REFERENCES merchandise(id)
);
CREATE TABLE funds (
id INTEGER PRIMARY KEY,
order_id INTEGER,
payment_date DATE,
quantity REAL,
technique TEXT,
FOREIGN KEY (order_id) REFERENCES orders(id)
);
INSERT INTO clients (id, identify, nation, signup_date) VALUES
(1,'Alice','USA','2024-01-05'),
(2,'Bob','UK','2024-03-10'),
(3,'Choi','KR','2024-06-22'),
(4,'Dara','ID','2025-01-15');
INSERT INTO merchandise (id, identify, class, value) VALUES
(1,'Laptop computer Professional','Electronics',1500.00),
(2,'Noise-Canceling Headphones','Electronics',300.00),
(3,'Standing Desk','Furnishings',450.00),
(4,'Ergonomic Chair','Furnishings',250.00),
(5,'Monitor 27"','Electronics',350.00);
INSERT INTO orders (id, customer_id, order_date, whole) VALUES
(1,1,'2025-02-01',1850.00),
(2,2,'2025-02-03',600.00),
(3,3,'2025-02-05',350.00),
(4,1,'2025-02-07',450.00);
INSERT INTO order_items (order_id, product_id, amount, unit_price) VALUES
(1,1,1,1500.00),
(1,2,1,300.00),
(1,5,1,350.00),
(2,3,1,450.00),
(2,4,1,250.00),
(3,5,1,350.00),
(4,3,1,450.00);
INSERT INTO funds (id, order_id, payment_date, quantity, technique) VALUES
(1,1,'2025-02-01',1850.00,'Credit score Card'),
(2,2,'2025-02-03',600.00,'PayPal'),
(3,3,'2025-02-05',350.00,'Credit score Card'),
(4,4,'2025-02-07',450.00,'Financial institution Switch');Führen Sie dann den folgenden Code in Ihrer CLI aus, um eine SQLite-Datenbank für unser Projekt zu erstellen.
sqlite3 demo.db < init_db.sql Wenn die Datenbank fertig ist, erstellen wir eine Dockerfile um unsere Anwendung zu containerisieren.
FROM python:3.12-slim
WORKDIR /code
COPY necessities.txt .
RUN pip set up --no-cache-dir -r necessities.txt
COPY . .
CMD ("uvicorn", "app.predominant:app", "--host", "0.0.0.0", "--port", "8000")Wir werden auch eine erstellen docker-compose.yml Datei für eine reibungslosere Ausführung der Anwendung.
providers:
text2sql:
construct: .
env_file: .env
ports:
- "8000:8000"
restart: unless-stopped
volumes:
- ./demo.db:/code/demo.dbWenn alles fertig ist, starten Sie Ihren Docker Desktop und führen Sie den folgenden Code aus, um die Anwendung zu erstellen.
docker compose construct --no-cache
docker compose up -d Wenn alles intestine gemacht ist, können Sie die Anwendung mithilfe des folgenden Codes testen. Wir werden fragen, wie viele Kunden wir in den Daten haben.
curl -X POST "http://localhost:8000/question" -H "Content material-Sort: software/json" -d "{"query":"What number of clients?"}"Die Ausgabe wird so aussehen.
{"sql":"SELECT COUNT(*) AS customer_count FROM clients;","end result":({"customer_count":4})}Wir können etwas Komplexeres ausprobieren, beispielsweise die Anzahl der Bestellungen für jeden Kunden:
curl -X POST "http://localhost:8000/question" -H "Content material-Sort: software/json" -d "{"query":"What's the variety of orders positioned by every buyer"}"Mit Ausgabe wie unten.
{"sql":"SELECT customer_id, COUNT(*) AS number_of_orders FROM orders GROUP BY customer_id;","end result":({"customer_id":1,"number_of_orders":2},{"customer_id":2,"number_of_orders":1},{"customer_id":3,"number_of_orders":1})}Das ist alles, was Sie zum Erstellen einer einfachen Textual content-to-SQL-Anwendung benötigen. Sie können es mit einer Entrance-Finish-Schnittstelle und einem komplexeren, auf Ihre Bedürfnisse zugeschnittenen System weiter ausbauen.
# Zusammenfassung
Daten sind das Herzstück jeder Datenarbeit und Unternehmen nutzen sie, um Entscheidungen zu treffen. Oft ist das System, das wir haben, zu komplex und wir müssen uns auf generative KI verlassen, um uns darin zurechtzufinden.
In diesem Artikel haben wir gelernt, wie man eine einfache Textual content-to-SQL-Anwendung mit dem OpenAI-Modell, FastAPI und SQLite entwickelt.
Ich hoffe, das hat geholfen!
Cornellius Yudha Wijaya ist stellvertretender Supervisor und Datenautor im Bereich Information Science. Während er Vollzeit bei Allianz Indonesia arbeitet, teilt er gerne Python- und Datentipps über soziale Medien und Schreibmedien. Cornellius schreibt über eine Vielzahl von Themen zu KI und maschinellem Lernen.