add csv ingestion and prompt templates

.gitignore

@@ -0,0 +1,3 @@
+__pycache__
+./__pycache__
+*/__pycache

app.py

@@ -1,35 +1,33 @@
 import streamlit as st
-from llama_cpp import Llama
-
-
-repo_ir = "Qwen/Qwen2.5-Coder-1.5B-Instruct-GGUF"
-llm = Llama.from_pretrained(
-    repo_id=repo_ir,
-    filename="qwen2.5-coder-1.5b-instruct-q8_0.gguf",
-    verbose=True,
-    use_mmap=True,
-    use_mlock=True,
-    n_threads=4,
-    n_threads_batch=4,
-    n_ctx=8000,
-)
-print(f"{repo_ir} loaded successfully. ✅")
-
-
-# Streamed response emulator
-def response_generator(messages):
-    completion = llm.create_chat_completion(
-        messages, max_tokens=2048, stream=True, temperature=0.7, top_p=0.95
-    )
+from llm import load_llm, response_generator
+from sql import csv_to_sqlite
+
 
-    for message in completion:
-        delta = message["choices"][0]["delta"]
-        if "content" in delta:
-            yield delta["content"]
+# repo_id = "Qwen/Qwen2.5-Coder-1.5B-Instruct-GGUF"
+repo_id = "Qwen/Qwen2.5-0.5B-Instruct-GGUF"
+# filename="qwen2.5-coder-1.5b-instruct-q8_0.gguf"
+filename = "qwen2.5-0.5b-instruct-q8_0.gguf"
 
+llm = load_llm(repo_id, filename)
 
 st.title("CSV TO SQL")
 
+with st.expander("Upload CSV"):
+    csv_file = st.file_uploader(
+        "CSV",
+    )
+    db_name = st.text_input("DB Name")
+    table_name = st.text_input("Table Name")
+    if st.button("Save"):
+        if csv_file and db_name and table_name:
+            st.session_state.db_name = db_name
+            st.session_state.table_name = table_name
+
+            csv_to_sqlite(csv_file, db_name, table_name)
+            st.write("Saved ✅")
+        else:
+            st.write("Please enter all values")
+
 # Initialize chat history
 if "messages" not in st.session_state:
     st.session_state.messages = []
@@ -47,14 +45,16 @@ if prompt := st.chat_input("What is up?"):
     with st.chat_message("user"):
         st.markdown(prompt)
 
-    messages = [{"role": "system", "content": "You are a helpful assistant"}]
-
-    for val in st.session_state.messages:
-        messages.append(val)
-
-    messages.append({"role": "user", "content": prompt})
     # Display assistant response in chat message container
     with st.chat_message("assistant"):
-        response = st.write_stream(response_generator(messages=messages))
+        response = st.write(
+            response_generator(
+                db_name=st.session_state.db_name,
+                table_name=st.session_state.table_name,
+                llm=llm,
+                messages=st.session_state.messages,
+                question=prompt,
+            )
+        )
     # Add assistant response to chat history
     st.session_state.messages.append({"role": "assistant", "content": response})

llm.py

@@ -0,0 +1,93 @@
+import streamlit as st
+from llama_cpp import Llama
+from sql import get_table_schema
+
+
+@st.cache_resource()
+def load_llm(repo_id, filename):
+    llm = Llama.from_pretrained(
+        repo_id=repo_id,
+        filename=filename,
+        verbose=True,
+        use_mmap=True,
+        use_mlock=True,
+        n_threads=4,
+        n_threads_batch=4,
+        n_ctx=8000,
+    )
+    print(f"{repo_id} loaded successfully. ✅")
+    return llm
+
+
+def generate_llm_prompt(table_name, table_schema):
+    """
+    Generates a prompt to provide context about a table's schema for LLM to convert natural language to SQL.
+
+    Args:
+        table_name (str): The name of the table.
+        table_schema (list): A list of tuples where each tuple contains information about the columns in the table.
+
+    Returns:
+        str: The generated prompt to be used by the LLM.
+    """
+    prompt = f"""You are an expert in writing SQL queries for relational databases. 
+    You will be provided with a database schema and a natural 
+    language question, and your task is to generate an accurate SQL query.
+    
+    The database has a table named '{table_name}' with the following schema:\n\n"""
+
+    prompt += "Columns:\n"
+
+    for col in table_schema:
+        column_name = col[1]
+        column_type = col[2]
+        prompt += f"- {column_name} ({column_type})\n"
+
+    prompt += "\nPlease generate a SQL query based on the following natural language question. ONLY return the SQL query."
+
+    return prompt
+
+
+def generate_sql_query(question, table_name, db_name):
+    pass
+    # table_name = 'movies'
+    # db_name = 'movies_db.db'
+    # table_schema = get_table_schema(db_name, table_name)
+    # llm_prompt = generate_llm_prompt(table_name, table_schema)
+    # user_prompt = """Question: {question}"""
+    # response = completion(
+    #     api_key=OPENAI_API_KEY,
+    #     model="gpt-4o-mini",
+    #     messages=[
+    #         ,
+    #         {"content": user_prompt.format(question=question),"role": "user"}],
+    #     max_tokens=1000
+    # )
+    # answer = response.choices[0].message.content
+
+    # query = answer.replace("```sql", "").replace("```", "")
+    # query = query.strip()
+    # return query
+
+
+# Streamed response emulator
+def response_generator(llm, messages, question, table_name, db_name):
+    table_schema = get_table_schema(db_name, table_name)
+    llm_prompt = generate_llm_prompt(table_name, table_schema)
+    user_prompt = """Question: {question}"""
+
+    messages = [{"content": llm_prompt.format(table_name=table_name), "role": "system"}]
+
+    for val in st.session_state.messages:
+        messages.append(val)
+
+    messages.append({"role": "user", "content": user_prompt})
+
+    response = llm.create_chat_completion(
+        messages, max_tokens=2048, temperature=0.7, top_p=0.95
+    )
+    answer = response["choices"][0].message.content
+
+    query = answer.replace("```sql", "").replace("```", "")
+    query = query.strip()
+    return query

sql.py

@@ -0,0 +1,102 @@
+import pandas as pd
+import sqlite3
+
+
+def csv_to_sqlite(csv_file, db_name, table_name):
+    # Read the CSV file into a pandas DataFrame
+    df = pd.read_csv(csv_file)
+
+    # Connect to the SQLite database (it will create the database file if it doesn't exist)
+    conn = sqlite3.connect(db_name)
+    cursor = conn.cursor()
+
+    # Infer the schema based on the DataFrame columns and data types
+    def create_table_from_df(df, table_name):
+        # Get column names and types
+        col_types = []
+        for col in df.columns:
+            dtype = df[col].dtype
+            if dtype == "int64":
+                col_type = "INTEGER"
+            elif dtype == "float64":
+                col_type = "REAL"
+            else:
+                col_type = "TEXT"
+            col_types.append(f'"{col}" {col_type}')
+
+        # Create the table schema
+        col_definitions = ", ".join(col_types)
+        create_table_query = (
+            f"CREATE TABLE IF NOT EXISTS {table_name} ({col_definitions});"
+        )
+        # print(create_table_query)
+
+        # Execute the table creation query
+        cursor.execute(create_table_query)
+        print(f"Table '{table_name}' created with schema: {col_definitions}")
+
+    # Create table schema
+    create_table_from_df(df, table_name)
+
+    # Insert CSV data into the SQLite table
+    df.to_sql(table_name, conn, if_exists="replace", index=False)
+
+    # Commit and close the connection
+    conn.commit()
+    conn.close()
+    print(f"Data loaded into '{table_name}' table in '{db_name}' SQLite database.")
+
+
+def run_sql_query(db_name, query):
+    """
+    Executes a SQL query on a SQLite database and returns the results.
+
+    Args:
+        db_name (str): The name of the SQLite database file.
+        query (str): The SQL query to run.
+
+    Returns:
+        list: Query result as a list of tuples, or an empty list if no results or error occurred.
+    """
+    try:
+        # Connect to the SQLite database
+        conn = sqlite3.connect(db_name)
+        cursor = conn.cursor()
+
+        # Execute the SQL query
+        cursor.execute(query)
+
+        # Fetch all results
+        results = cursor.fetchall()
+
+        # Close the connection
+        conn.close()
+
+        # Return results or an empty list if no results were found
+        return results if results else []
+
+    except sqlite3.Error as e:
+        print(f"An error occurred while executing the query: {e}")
+        return []
+
+
+def get_table_schema(db_name, table_name):
+    """
+    Retrieves the schema (columns and data types) for a given table in the SQLite database.
+
+    Args:
+        db_name (str): The name of the SQLite database file.
+        table_name (str): The name of the table.
+
+    Returns:
+        list: A list of tuples with column name, data type, and other info.
+    """
+    conn = sqlite3.connect(db_name)
+    cursor = conn.cursor()
+
+    # Use PRAGMA to get the table schema
+    cursor.execute(f"PRAGMA table_info({table_name});")
+    schema = cursor.fetchall()
+
+    conn.close()
+    return schema