Talk to Your DB

# database.py
import pymysql
from urllib.parse import urlparse

def parse_connection_string(connection_string):
    """Parse MySQL connection string"""
    parsed = urlparse(connection_string)
    return {
        'host': parsed.hostname,
        'user': parsed.username,
        'password': parsed.password,
        'database': parsed.path[1:],
        'port': parsed.port or 3306,
        'ssl': {'ssl': True}
    }

def execute_query(sql_query):
    """Execute SQL query and return results"""
    try:
        connection = pymysql.connect(**db_config)
        with connection.cursor() as cursor:
            cursor.execute(sql_query)
            results = cursor.fetchall()
        return results, None
    except Exception as e:
        return None, str(e)

# ai_services.py
from langchain_nebius import ChatNebius
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
import os

# Database schema information
DB_SCHEMA = """
Database: Ecommerce (MySQL)
Tables:
- category (id, uuid, name, description, date_created, date_updated)
- product (id, uuid, name, description, price, stock_quantity, category_id)
- user (id, uuid, name, email, address)
- order (id, uuid, user_id, total_amount, status, order_date)
- order_item (id, order_id, product_id, quantity, unit_price)

Relationships:
- product.category_id -> category.id
- order.user_id -> user.id
- order_item.order_id -> order.id
- order_item.product_id -> product.id
"""

def get_llm():
    """Get the Nebius LLM instance"""
    return ChatNebius(
        model="zai-org/GLM-4.5-Air",
        temperature=0.1,
        top_p=0.95,
        api_key=os.getenv("NEBIUS_API_KEY"),
    )

def translate_to_sql(natural_question):
    """Translate natural language to SQL"""
    llm = get_llm()
    
    prompt = ChatPromptTemplate.from_messages([
        ("system", """
You are a MySQL SQL expert. Convert natural language questions to MySQL queries.

Database Schema:
{db_schema}

Rules:
1. Use appropriate JOINs when needed
2. Use MySQL syntax with backticks for identifiers
3. Include LIMIT 100 for large result sets
4. Return ONLY the SQL query, no explanations

Example:
Question: "What are the product categories we have?"
SELECT `id`, `name`, `description` FROM `category` ORDER BY `name`;
        """),
        ("human", "Question: {question}\n\nGenerate the SQL query:")
    ])
    
    chain = prompt | llm | StrOutputParser()
    
    sql_query = chain.invoke({
        "db_schema": DB_SCHEMA,
        "question": natural_question,
    })
    
    return sql_query.strip()

def explain_results(results, original_question):
    """Generate plain English explanation of results"""
    llm = get_llm()
    
    results_text = json.dumps(results, indent=2, default=str)
    
    prompt = ChatPromptTemplate.from_messages([
        ("system", """
You are a helpful database assistant. Explain query results in plain English.

Rules:
1. Be conversational and clear
2. Summarize key findings
3. Provide statistics for many results
4. Highlight interesting patterns
5. Keep it concise but informative
        """),
        ("human", """
Original Question: {question}

Query Results:
{results}

Please explain these results in plain English:
        """)
    ])
    
    chain = prompt | llm | StrOutputParser()
    
    explanation = chain.invoke({
        "question": original_question,
        "results": results_text
    })
    
    return explanation.strip()

talk_to_db/
├── app.py              # Streamlit web interface
├── database.py         # Database connection and query execution
├── ai_services.py      # AI-powered SQL generation and explanation
├── requirements.txt    # Python dependencies
├── assets/
│   ├── demo.png        # Demo screenshot
│   ├── langchain.png   # LangChain logo
│   ├── gibson.svg      # GibsonAI logo
│   └── nebius.png      # Nebius logo
└── README.md           # Documentation

mysql://username:password@host/database