Initial Push

.env.sample

@@ -0,0 +1,6 @@
+LANGCHAIN_TRACING_V2=
+LANGCHAIN_ENDPOINT=
+LANGCHAIN_PROJECT=
+LANGSMITH_API_KEY=
+OPENAI_API_KEY=
+

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+data/sqlite-sakila.db filter=lfs diff=lfs merge=lfs -text
+data/SQLite3[[:space:]]Sakila[[:space:]]Sample[[:space:]]Database[[:space:]]ERD.png filter=lfs diff=lfs merge=lfs -text
+data/sqlite-sakila-db/sqlite-sakila.sq filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,23 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first to leverage Docker cache
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application
+COPY . .
+
+# Expose the port the app runs on
+EXPOSE 8000
+
+# Command to run the application
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -1,10 +1,11 @@
 ---
 title: Text To Sql Agent Api
-emoji: 🌍
-colorFrom: yellow
-colorTo: gray
+emoji: 🐨
+colorFrom: indigo
+colorTo: indigo
 sdk: docker
 pinned: false
+short_description: SQL agent to converse with structured databases
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app/__init__.py

@@ -0,0 +1,3 @@
+"""
+InsightCopilot backend application package.
+"""

app/agent/.gitignore

@@ -0,0 +1,176 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+/data

app/agent/__init__.py

@@ -0,0 +1,3 @@
+"""
+LangGraph agent package.
+"""

app/agent/configuration.py

@@ -0,0 +1,48 @@
+"""Define the configurable parameters for the agent."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field, fields
+from typing import Annotated
+
+from app.agent import prompts
+from langchain_core.runnables import ensure_config
+from langgraph.config import get_config
+
+
+@dataclass(kw_only=True)
+class Configuration:
+    """The configuration for the agent."""
+
+    system_prompt: str = field(
+        default=prompts.SYSTEM_PROMPT,
+        metadata={
+            "description": "The system prompt to use for the agent's interactions. "
+            "This prompt sets the context and behavior for the agent."
+        },
+    )
+
+    model: Annotated[str, {"__template_metadata__": {"kind": "llm"}}] = field(
+        default="openai/gpt-4o",
+        metadata={
+            "description": "The name of the language model to use for the agent's main interactions. "
+            "Should be in the form: provider/model-name."
+        },
+    )
+
+    max_search_results: int = field(
+        default=10,
+        metadata={"description": "The maximum number of search results to return for each search query."},
+    )
+
+    @classmethod
+    def from_context(cls) -> Configuration:
+        """Create a Configuration instance from a RunnableConfig object."""
+        try:
+            config = get_config()
+        except RuntimeError:
+            config = None
+        config = ensure_config(config)
+        configurable = config.get("configurable") or {}
+        _fields = {f.name for f in fields(cls) if f.init}
+        return cls(**{k: v for k, v in configurable.items() if k in _fields})

app/agent/graph.py

@@ -0,0 +1,167 @@
+"""Define a custom Reasoning and Action agent.
+
+Works with a chat model with tool calling support.
+"""
+
+from typing import Dict, List, Literal, cast
+
+from app.agent.configuration import Configuration
+from app.agent.state import AgentState, InputState, SQLAgentState
+from app.agent.tools import TOOLS
+from app.agent.utils import load_chat_model
+from dotenv import load_dotenv
+from langchain_core.messages import AIMessage
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.graph import StateGraph
+from langgraph.prebuilt import ToolNode
+
+load_dotenv()
+
+# Define the function that calls the model
+async def call_model(state: AgentState) -> Dict[str, List[AIMessage]]:
+    """Call the LLM powering our "agent".
+
+    This function prepares the prompt, initializes the model, and processes the response.
+
+    Args:
+        state (State): The current state of the conversation.
+        config (RunnableConfig): Configuration for the model run.
+
+    Returns:
+        dict: A dictionary containing the model's response message.
+    """
+    configuration = Configuration.from_context()
+
+    # Initialize the model with tool binding. Change the model or add more tools here.
+    model = load_chat_model(configuration.model).bind_tools(TOOLS)
+
+    # Format the system prompt. Customize this to change the agent's behavior.
+    system_message = configuration.system_prompt
+
+    # Get the model's response
+    response = cast(
+        AIMessage,
+        await model.ainvoke([{"role": "system", "content": system_message}, *state.messages]),
+    )
+
+    # Handle the case when it's the last step and the model still wants to use a tool
+    if state.is_last_step and response.tool_calls:
+        return {
+            "messages": [
+                AIMessage(
+                    id=response.id,
+                    content="Sorry, I could not find an answer to your question in the specified number of steps.",
+                )
+            ]
+        }
+
+    # Return the model's response as a list to be added to existing messages
+    return {"messages": [response]}
+
+
+# Define a new graph
+builder = StateGraph(AgentState, input=InputState, config_schema=Configuration)
+
+# Define the two nodes we will cycle between
+builder.add_node(call_model)
+builder.add_node("tools", ToolNode(TOOLS))
+
+# Set the entrypoint as `call_model`
+# This means that this node is the first one called
+builder.add_edge("__start__", "call_model")
+
+
+def route_model_output(state: SQLAgentState) -> Literal["__end__", "tools"]:
+    """Determine the next node based on the model's output."""
+    last_message = state.messages[-1]
+    if not isinstance(last_message, AIMessage):
+        raise ValueError(f"Expected AIMessage in output edges, but got {type(last_message).__name__}")
+
+    # If there is no tool call, then we finish
+    if not last_message.tool_calls:
+        return "__end__"
+
+    # If we've exceeded max attempts, end the conversation
+    if state.query_attempts >= 3:
+        return "__end__"
+
+    # Otherwise execute the requested actions
+    return "tools"
+
+
+# Add a conditional edge to determine the next step after `call_model`
+builder.add_conditional_edges(
+    "call_model",
+    # After call_model finishes running, the next node(s) are scheduled
+    # based on the output from route_model_output
+    route_model_output,
+)
+
+# Add a normal edge from `tools` to `call_model`
+# This creates a cycle: after using tools, we always return to the model
+builder.add_edge("tools", "call_model")
+
+# Compile the builder into an executable graph
+memory = MemorySaver()
+graph = builder.compile(name="powersim_agent")
+
+if __name__ == "__main__":
+    import asyncio
+
+    from langchain_core.messages import HumanMessage
+
+    async def main():
+        # Define the input using proper message format
+        input_data = {
+            "messages": [
+                HumanMessage(content="What is the total revenue?"),
+            ]
+        }
+
+        config = {
+            "configurable": {
+                "thread_id": "12345",
+            }
+        }
+
+        # Stream the execution to see what's happening inside
+        print("\n=== STARTING AGENT EXECUTION ===\n")
+
+        # Use astream to see intermediate steps
+        async for chunk in graph.astream(input_data, config, stream_mode="updates"):
+            for node_name, node_output in chunk.items():
+                print(f"\n--- OUTPUT FROM NODE: {node_name} ---")
+
+                # Extract messages if they exist
+                if "messages" in node_output and node_output["messages"]:
+                    latest_message = node_output["messages"][-1]
+
+                    # Print message content based on type
+                    print(f"MESSAGE TYPE: {type(latest_message).__name__}")
+
+                    if hasattr(latest_message, "content") and latest_message.content:
+                        print(f"CONTENT: {latest_message.content[:500]}...")
+
+                    # Print tool calls if present
+                    if hasattr(latest_message, "tool_calls") and latest_message.tool_calls:
+                        print(f"TOOL CALLS: {latest_message.tool_calls}")
+
+                    # Handle tool messages specifically
+                    if hasattr(latest_message, "name") and hasattr(latest_message, "tool_call_id"):
+                        print(f"TOOL: {latest_message.name}")
+                        print(f"TOOL CALL ID: {latest_message.tool_call_id}")
+                        if hasattr(latest_message, "content"):
+                            print(f"RESULT: {latest_message.content[:500]}...")
+
+                print("-----------------------------------")
+
+            print("\n==== CHUNK COMPLETE ====\n")
+
+        # Get the final response
+        final_response = await graph.ainvoke(input_data, config)
+
+        print("\n=== FINAL RESPONSE ===\n")
+        print(final_response)
+
+    # Run the async main function
+    asyncio.run(main())

app/agent/langgraph.json

@@ -0,0 +1,7 @@
+{
+    "dependencies": ["."],
+    "graphs": {
+      "agent": "./app/agent/graph.py:graph"
+    },
+    "env": ".env"
+  }

app/agent/prompts.py

@@ -0,0 +1,37 @@
+"""Prompts used by the agent."""
+
+SYSTEM_PROMPT = """
+You are an AI agent designed to interact with a SQLite database.
+Your task is to:
+1. Understand natural language questions
+2. Convert them into valid SQL queries
+3. Execute the queries and return meaningful results
+
+Guidelines:
+- Always start by examining the database schema using the get_schema tool
+- Write SQL queries that are specific to the question
+- Only query relevant columns
+- Use appropriate JOINs and WHERE clauses
+- Limit results to reasonable numbers (default 10)
+- Handle errors gracefully
+- Never make DML statements (INSERT, UPDATE, DELETE, DROP)
+
+When generating SQL:
+- Use proper SQLite syntax
+- Include appropriate table aliases
+- Use meaningful column names in the output
+- Add comments for complex queries
+- Validate query structure before execution
+
+If a query fails:
+1. Analyze the error message
+2. Check the schema again
+3. Rewrite the query with corrections
+4. Try again with the modified query
+
+Remember to:
+- Double-check your queries before execution
+- Format results in a clear, readable way
+- Explain your reasoning when necessary
+- Handle edge cases appropriately
+"""

app/agent/state.py

@@ -0,0 +1,69 @@
+# Define agent state
+from dataclasses import dataclass, field
+from typing import Annotated, Dict, List, Optional, Sequence
+
+from copilotkit import CopilotKitState  # noqa: F401
+from langchain_core.messages import AnyMessage
+from langgraph.graph import add_messages
+from langgraph.managed import IsLastStep, RemainingSteps
+
+
+def merge_lists(a: list, b: list) -> list:
+    """Merge two lists by extending the first with the second"""
+    return [*a, *b] if isinstance(a, list) and isinstance(b, list) else b
+
+
+@dataclass
+class InputState:
+    """Defines the input state for the agent, representing a narrower interface to the outside world.
+
+    This class is used to define the initial state and structure of incoming data.
+    """
+
+    messages: Annotated[Sequence[AnyMessage], add_messages] = field(default_factory=list)
+    """
+    Messages tracking the primary execution state of the agent.
+
+    Typically accumulates a pattern of:
+    1. HumanMessage - user input
+    2. AIMessage with .tool_calls - agent picking tool(s) to use to collect information
+    3. ToolMessage(s) - the responses (or errors) from the executed tools
+    4. AIMessage without .tool_calls - agent responding in unstructured format to the user
+    5. HumanMessage - user responds with the next conversational turn
+
+    Steps 2-5 may repeat as needed.
+
+    The `add_messages` annotation ensures that new messages are merged with existing ones,
+    updating by ID to maintain an "append-only" state unless a message with the same ID is provided.
+    """
+
+
+@dataclass
+class AgentState(InputState):
+    remaining_steps: RemainingSteps = 25
+    is_last_step: IsLastStep = field(default=False)
+    progress: Optional[str] = None
+
+    def items(self):
+        """Make AgentState behave like a dictionary for CopilotKit compatibility.
+
+        This method returns key-value pairs for all attributes in the dataclass.
+        """
+        return self.__dict__.items()
+
+    def __getitem__(self, key):
+        """Support dictionary-like access."""
+        return getattr(self, key)
+
+    def get(self, key, default=None):
+        """Provide dictionary-like get method with default support."""
+        return getattr(self, key, default)
+
+
+@dataclass
+class SQLAgentState(AgentState):
+    """Extended state for SQL agent with query tracking."""
+
+    last_query: Optional[str] = None
+    query_attempts: int = 0
+    schema: Optional[Dict[str, List[str]]] = None

app/agent/tools.py

@@ -0,0 +1,80 @@
+import json
+import sqlite3
+from pathlib import Path
+from typing import Any, Callable, Dict, List
+
+import pandas as pd
+from copilotkit.langgraph import copilotkit_emit_state
+from langchain_core.runnables.config import RunnableConfig
+from langchain_core.tools import tool
+from langchain_core.tools.base import InjectedToolCallId
+from langgraph.prebuilt import InjectedState
+from tenacity import retry, stop_after_attempt, wait_exponential
+from typing_extensions import Annotated
+
+# Database path
+DB_PATH = Path(__file__).parent.parent.parent / "data" / "sqlite-sakila.db"
+
+
+class SQLiteDatabase:
+    def __init__(self, db_path: Path):
+        self.db_path = db_path
+
+    @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=10))
+    def execute_query(self, query: str) -> pd.DataFrame:
+        """Execute a SQL query with retry logic."""
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                return pd.read_sql_query(query, conn)
+        except sqlite3.Error as e:
+            raise Exception(f"Database error: {str(e)}")
+        except Exception as e:
+            raise Exception(f"Unexpected error: {str(e)}")
+
+    def get_schema(self) -> Dict[str, List[str]]:
+        """Get the database schema."""
+        schema = {}
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
+            tables = cursor.fetchall()
+
+            for table in tables:
+                table_name = table[0]
+                cursor.execute(f"PRAGMA table_info({table_name});")
+                columns = cursor.fetchall()
+                schema[table_name] = [col[1] for col in columns]
+        return schema
+
+
+# Initialize database
+db = SQLiteDatabase(DB_PATH)
+
+
+@tool(description="Get the database schema", return_direct=False)
+async def get_schema(
+    tool_call_id: Annotated[str, InjectedToolCallId],
+    state: Annotated[Any, InjectedState],
+) -> str:
+    """Get the database schema."""
+    schema = db.get_schema()
+    return json.dumps(schema, indent=2)
+
+
+@tool(description="Run a query on the database", return_direct=True)
+async def run_query(
+    tool_call_id: Annotated[str, InjectedToolCallId],
+    state: Annotated[Any, InjectedState],
+    config: RunnableConfig,
+    query: str,
+) -> str:
+    """Run a SQL query on the database with retry logic."""
+    await copilotkit_emit_state(config, {"progress": "Running query..."})
+    try:
+        result = db.execute_query(query)
+        return result.to_json(orient="records")
+    except Exception as e:
+        return f"Error executing query: {str(e)}"
+
+
+TOOLS: List[Callable[..., Any]] = [get_schema, run_query]

app/agent/utils.py

@@ -0,0 +1,67 @@
+import re
+from typing import List
+
+from IPython.display import Image, display
+from langchain.chat_models import init_chat_model
+from langchain_core.language_models import BaseChatModel
+
+
+def parse_inf_file(inf_path: str) -> List[str]:
+    """
+    Parse a PSCAD .inf file and extract column descriptions.
+
+    Args:
+        inf_path (str): Path to the .inf file
+
+    Returns:
+        List[str]: List of column descriptions in order
+    """
+    column_names = []
+    pgb_pattern = re.compile(r'PGB\(\d+\)\s+Output\s+Desc="([^"]+)"')
+
+    try:
+        with open(inf_path, "r") as f:
+            for line in f:
+                match = pgb_pattern.search(line)
+                if match:
+                    column_names.append(match.group(1))
+    except Exception as e:
+        print(f"Error parsing .inf file {inf_path}: {e}")
+
+    return column_names
+
+
+def save_graph_diagram(graph, filename="graph.png"):
+    """
+    Generate and save a graph of the given graph.
+
+    Args:
+        graph: The graph to be depicted.
+        filename: The name of the file to save the graph as.
+    """
+    try:
+        graph = graph.get_graph(xray=True).draw_mermaid_png()
+        with open(filename, "wb") as f:
+            f.write(graph)
+        display(Image(filename))
+    except Exception as e:
+        print(f"An error occurred while generating the graph: {e}")
+
+
+def print_stream(stream):
+    for s in stream:
+        message = s["messages"][-1]
+        if isinstance(message, tuple):
+            print(message)
+        else:
+            message.pretty_print()
+
+
+def load_chat_model(fully_specified_name: str) -> BaseChatModel:
+    """Load a chat model from a fully specified name.
+
+    Args:
+        fully_specified_name (str): String in the format 'provider/model'.
+    """
+    provider, model = fully_specified_name.split("/", maxsplit=1)
+    return init_chat_model(model, model_provider=provider)

app/api/__init__.py

@@ -0,0 +1,3 @@
+"""
+API endpoints package.
+"""

app/api/insights.py

@@ -0,0 +1,268 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy import desc, distinct, func
+from sqlalchemy.orm import Session
+
+from ..db.database import get_db
+from ..db.models import (
+    Actor,
+    Address,
+    Category,
+    City,
+    Country,
+    Customer,
+    Film,
+    Inventory,
+    Payment,
+    Rental,
+    Store,
+)
+
+router = APIRouter()
+
+
+@router.get("/insights")
+async def get_insights(db: Session = Depends(get_db)):
+    try:
+        # TODO: Implement insights generation logic
+        return {"status": "success", "insights": []}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/insights/top-films")
+async def get_top_films(limit: int = 10, db: Session = Depends(get_db)):
+    try:
+        # Get top films by rental count
+        top_films = (
+            db.query(
+                Film.title,
+                func.count(Rental.rental_id).label("rental_count"),
+                Film.rental_rate,
+                func.sum(Payment.amount).label("total_revenue"),
+            )
+            .join(Rental, Film.film_id == Rental.inventory_id)
+            .join(Payment, Rental.rental_id == Payment.rental_id)
+            .group_by(Film.film_id)
+            .order_by(desc("rental_count"))
+            .limit(limit)
+            .all()
+        )
+
+        return {
+            "status": "success",
+            "data": [
+                {
+                    "title": film.title,
+                    "rental_count": film.rental_count,
+                    "rental_rate": float(film.rental_rate),
+                    "total_revenue": float(film.total_revenue),
+                }
+                for film in top_films
+            ],
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/insights/category-performance")
+async def get_category_performance(db: Session = Depends(get_db)):
+    try:
+        # Get performance metrics by category
+        category_stats = (
+            db.query(
+                Category.name,
+                func.count(Film.film_id).label("film_count"),
+                func.avg(Film.rental_rate).label("avg_rental_rate"),
+                func.sum(Payment.amount).label("total_revenue"),
+            )
+            .join(Film, Category.category_id == Film.film_id)
+            .join(Rental, Film.film_id == Rental.inventory_id)
+            .join(Payment, Rental.rental_id == Payment.rental_id)
+            .group_by(Category.category_id)
+            .all()
+        )
+
+        return {
+            "status": "success",
+            "data": [
+                {
+                    "category": cat.name,
+                    "film_count": cat.film_count,
+                    "avg_rental_rate": float(cat.avg_rental_rate),
+                    "total_revenue": float(cat.total_revenue),
+                }
+                for cat in category_stats
+            ],
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/insights/customer-activity")
+async def get_customer_activity(limit: int = 10, db: Session = Depends(get_db)):
+    try:
+        # Get most active customers
+        active_customers = (
+            db.query(
+                Customer.first_name,
+                Customer.last_name,
+                func.count(Rental.rental_id).label("rental_count"),
+                func.sum(Payment.amount).label("total_spent"),
+            )
+            .join(Rental, Customer.customer_id == Rental.customer_id)
+            .join(Payment, Rental.rental_id == Payment.rental_id)
+            .group_by(Customer.customer_id)
+            .order_by(desc("total_spent"))
+            .limit(limit)
+            .all()
+        )
+
+        return {
+            "status": "success",
+            "data": [
+                {
+                    "customer_name": f"{cust.first_name} {cust.last_name}",
+                    "rental_count": cust.rental_count,
+                    "total_spent": float(cust.total_spent),
+                }
+                for cust in active_customers
+            ],
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/insights/store-performance")
+async def get_store_performance(db: Session = Depends(get_db)):
+    try:
+        # Get store performance metrics
+        store_stats = (
+            db.query(
+                Store.store_id,
+                func.count(Rental.rental_id).label("rental_count"),
+                func.sum(Payment.amount).label("total_revenue"),
+                func.avg(Payment.amount).label("avg_transaction"),
+            )
+            .join(Rental, Store.store_id == Rental.staff_id)
+            .join(Payment, Rental.rental_id == Payment.rental_id)
+            .group_by(Store.store_id)
+            .all()
+        )
+
+        return {
+            "status": "success",
+            "data": [
+                {
+                    "store_id": store.store_id,
+                    "rental_count": store.rental_count,
+                    "total_revenue": float(store.total_revenue),
+                    "avg_transaction": float(store.avg_transaction),
+                }
+                for store in store_stats
+            ],
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/insights/actor-popularity")
+async def get_actor_popularity(limit: int = 10, db: Session = Depends(get_db)):
+    try:
+        # Get most popular actors based on film rentals
+        popular_actors = (
+            db.query(
+                Actor.first_name,
+                Actor.last_name,
+                func.count(Rental.rental_id).label("rental_count"),
+                func.sum(Payment.amount).label("total_revenue"),
+            )
+            .join(Film, Actor.actor_id == Film.film_id)
+            .join(Rental, Film.film_id == Rental.inventory_id)
+            .join(Payment, Rental.rental_id == Payment.rental_id)
+            .group_by(Actor.actor_id)
+            .order_by(desc("rental_count"))
+            .limit(limit)
+            .all()
+        )
+
+        return {
+            "status": "success",
+            "data": [
+                {
+                    "actor_name": f"{actor.first_name} {actor.last_name}",
+                    "rental_count": actor.rental_count,
+                    "total_revenue": float(actor.total_revenue),
+                }
+                for actor in popular_actors
+            ],
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/insights/sales-overview")
+async def get_sales_overview(db: Session = Depends(get_db)):
+    try:
+        # Get monthly sales data for the past year
+        sales_data = (
+            db.query(
+                func.strftime("%Y-%m", Payment.payment_date).label("date"),
+                func.sum(Payment.amount).label("Sales"),
+                func.sum(Payment.amount * 0.7).label("Profit"),  # Assuming 70% profit margin
+                func.sum(Payment.amount * 0.3).label("Expenses"),  # Assuming 30% expenses
+                func.count(distinct(Rental.customer_id)).label("Customers"),
+            )
+            .join(Rental, Payment.rental_id == Rental.rental_id)
+            .group_by(func.strftime("%Y-%m", Payment.payment_date))
+            .order_by(func.strftime("%Y-%m", Payment.payment_date))
+            .limit(12)
+            .all()
+        )
+
+        return {
+            "status": "success",
+            "data": [
+                {
+                    "date": sale.date,
+                    "Sales": float(sale.Sales),
+                    "Profit": float(sale.Profit),
+                    "Expenses": float(sale.Expenses),
+                    "Customers": sale.Customers,
+                }
+                for sale in sales_data
+            ],
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/insights/regional-sales")
+async def get_regional_sales(db: Session = Depends(get_db)):
+    try:
+        # Get sales data by country
+        regional_data = (
+            db.query(
+                Country.country.label("region"),
+                func.sum(Payment.amount).label("sales"),
+                func.count(distinct(Rental.customer_id)).label("marketShare"),
+            )
+            .join(City, Country.country_id == City.country_id)
+            .join(Address, City.city_id == Address.city_id)
+            .join(Store, Address.address_id == Store.address_id)
+            .join(Inventory, Store.store_id == Inventory.store_id)
+            .join(Rental, Inventory.inventory_id == Rental.inventory_id)
+            .join(Payment, Rental.rental_id == Payment.rental_id)
+            .group_by(Country.country)
+            .order_by(func.sum(Payment.amount).desc())
+            .all()
+        )
+
+        return {
+            "status": "success",
+            "data": [
+                {"region": region.region, "sales": float(region.sales), "marketShare": region.marketShare}
+                for region in regional_data
+            ],
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

app/api/query.py

@@ -0,0 +1,17 @@
+from typing import Any, Dict
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+
+from ..db.database import get_db
+
+router = APIRouter()
+
+
+@router.post("/query")
+async def process_query(query: Dict[str, Any], db: Session = Depends(get_db)):
+    try:
+        # TODO: Implement query processing logic
+        return {"status": "success", "message": "Query received"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

app/db/__init__.py

@@ -0,0 +1,3 @@
+"""
+Database package.
+"""

app/db/database.py

@@ -0,0 +1,27 @@
+import os
+
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+
+# Get the absolute path to the data directory
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+DATABASE_PATH = os.path.join(BASE_DIR, "data", "sqlite-sakila.db")
+
+# Ensure the data directory exists
+os.makedirs(os.path.dirname(DATABASE_PATH), exist_ok=True)
+
+SQLALCHEMY_DATABASE_URL = f"sqlite:///{DATABASE_PATH}"
+
+engine = create_engine(SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False})
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()
+
+# Dependency
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

app/db/models.py

@@ -0,0 +1,211 @@
+from sqlalchemy import (
+    Boolean,
+    Column,
+    DateTime,
+    ForeignKey,
+    Integer,
+    Numeric,
+    SmallInteger,
+    String,
+    Text,
+)
+from sqlalchemy.orm import relationship
+
+from .database import Base
+
+
+class Actor(Base):
+    __tablename__ = "actor"
+
+    actor_id = Column(Integer, primary_key=True)
+    first_name = Column(String(45), nullable=False)
+    last_name = Column(String(45), nullable=False)
+    last_update = Column(DateTime, nullable=False)
+    films = relationship("Film", secondary="film_actor", back_populates="actors")
+
+
+class Category(Base):
+    __tablename__ = "category"
+
+    category_id = Column(SmallInteger, primary_key=True)
+    name = Column(String(25), nullable=False)
+    last_update = Column(DateTime, nullable=False)
+    films = relationship("Film", secondary="film_category", back_populates="categories")
+
+
+class Film(Base):
+    __tablename__ = "film"
+
+    film_id = Column(Integer, primary_key=True)
+    title = Column(String(255), nullable=False)
+    description = Column(Text)
+    release_year = Column(String(4))
+    language_id = Column(SmallInteger, ForeignKey("language.language_id"), nullable=False)
+    original_language_id = Column(SmallInteger, ForeignKey("language.language_id"))
+    rental_duration = Column(SmallInteger, nullable=False, default=3)
+    rental_rate = Column(Numeric(4, 2), nullable=False, default=4.99)
+    length = Column(SmallInteger)
+    replacement_cost = Column(Numeric(5, 2), nullable=False, default=19.99)
+    rating = Column(String(10), default="G")
+    special_features = Column(String(100))
+    last_update = Column(DateTime, nullable=False)
+    language = relationship("Language", foreign_keys=[language_id])
+    original_language = relationship("Language", foreign_keys=[original_language_id])
+    inventory = relationship("Inventory", back_populates="film")
+    actors = relationship("Actor", secondary="film_actor", back_populates="films")
+    categories = relationship("Category", secondary="film_category", back_populates="films")
+
+
+class Customer(Base):
+    __tablename__ = "customer"
+
+    customer_id = Column(Integer, primary_key=True)
+    store_id = Column(Integer, ForeignKey("store.store_id"), nullable=False)
+    first_name = Column(String(45), nullable=False)
+    last_name = Column(String(45), nullable=False)
+    email = Column(String(50))
+    address_id = Column(Integer, ForeignKey("address.address_id"), nullable=False)
+    active = Column(Boolean, nullable=False, default=True)
+    create_date = Column(DateTime, nullable=False)
+    last_update = Column(DateTime, nullable=False)
+    store = relationship("Store", back_populates="customers")
+    address = relationship("Address", back_populates="customers")
+    rentals = relationship("Rental", back_populates="customer")
+    payments = relationship("Payment", back_populates="customer")
+
+
+class Store(Base):
+    __tablename__ = "store"
+
+    store_id = Column(Integer, primary_key=True)
+    manager_staff_id = Column(SmallInteger, ForeignKey("staff.staff_id"), nullable=False)
+    address_id = Column(Integer, ForeignKey("address.address_id"), nullable=False)
+    last_update = Column(DateTime, nullable=False)
+    address = relationship("Address", back_populates="stores")
+    manager = relationship("Staff", foreign_keys=[manager_staff_id])
+    inventory = relationship("Inventory", back_populates="store")
+    customers = relationship("Customer", back_populates="store")
+
+
+class Rental(Base):
+    __tablename__ = "rental"
+
+    rental_id = Column(Integer, primary_key=True)
+    rental_date = Column(DateTime, nullable=False)
+    inventory_id = Column(Integer, ForeignKey("inventory.inventory_id"), nullable=False)
+    customer_id = Column(Integer, ForeignKey("customer.customer_id"), nullable=False)
+    return_date = Column(DateTime)
+    staff_id = Column(SmallInteger, ForeignKey("staff.staff_id"), nullable=False)
+    last_update = Column(DateTime, nullable=False)
+    inventory = relationship("Inventory", back_populates="rentals")
+    customer = relationship("Customer", back_populates="rentals")
+    staff = relationship("Staff", back_populates="rentals")
+    payments = relationship("Payment", back_populates="rental")
+
+
+class Payment(Base):
+    __tablename__ = "payment"
+
+    payment_id = Column(Integer, primary_key=True)
+    customer_id = Column(Integer, ForeignKey("customer.customer_id"), nullable=False)
+    staff_id = Column(SmallInteger, ForeignKey("staff.staff_id"), nullable=False)
+    rental_id = Column(Integer, ForeignKey("rental.rental_id"))
+    amount = Column(Numeric(5, 2), nullable=False)
+    payment_date = Column(DateTime, nullable=False)
+    last_update = Column(DateTime, nullable=False)
+    customer = relationship("Customer", back_populates="payments")
+    staff = relationship("Staff", back_populates="payments")
+    rental = relationship("Rental", back_populates="payments")
+
+
+class Country(Base):
+    __tablename__ = "country"
+
+    country_id = Column(SmallInteger, primary_key=True)
+    country = Column(String(50), nullable=False)
+    last_update = Column(DateTime)
+    cities = relationship("City", back_populates="country")
+
+
+class City(Base):
+    __tablename__ = "city"
+
+    city_id = Column(Integer, primary_key=True)
+    city = Column(String(50), nullable=False)
+    country_id = Column(SmallInteger, ForeignKey("country.country_id"), nullable=False)
+    last_update = Column(DateTime, nullable=False)
+    country = relationship("Country", back_populates="cities")
+    addresses = relationship("Address", back_populates="city")
+
+
+class Address(Base):
+    __tablename__ = "address"
+
+    address_id = Column(Integer, primary_key=True)
+    address = Column(String(50), nullable=False)
+    address2 = Column(String(50))
+    district = Column(String(20), nullable=False)
+    city_id = Column(Integer, ForeignKey("city.city_id"), nullable=False)
+    postal_code = Column(String(10))
+    phone = Column(String(20), nullable=False)
+    last_update = Column(DateTime, nullable=False)
+    city = relationship("City", back_populates="addresses")
+    stores = relationship("Store", back_populates="address")
+    customers = relationship("Customer", back_populates="address")
+    staff = relationship("Staff", back_populates="address")
+
+
+class Staff(Base):
+    __tablename__ = "staff"
+
+    staff_id = Column(SmallInteger, primary_key=True)
+    first_name = Column(String(45), nullable=False)
+    last_name = Column(String(45), nullable=False)
+    address_id = Column(Integer, ForeignKey("address.address_id"), nullable=False)
+    picture = Column(Text)
+    email = Column(String(50))
+    store_id = Column(Integer, ForeignKey("store.store_id"), nullable=False)
+    active = Column(SmallInteger, nullable=False, default=1)
+    username = Column(String(16), nullable=False)
+    password = Column(String(40))
+    last_update = Column(DateTime, nullable=False)
+    address = relationship("Address", back_populates="staff")
+    store = relationship("Store", foreign_keys=[store_id])
+    rentals = relationship("Rental", back_populates="staff")
+    payments = relationship("Payment", back_populates="staff")
+
+
+class Language(Base):
+    __tablename__ = "language"
+
+    language_id = Column(SmallInteger, primary_key=True)
+    name = Column(String(20), nullable=False)
+    last_update = Column(DateTime, nullable=False)
+
+
+class Inventory(Base):
+    __tablename__ = "inventory"
+
+    inventory_id = Column(Integer, primary_key=True)
+    film_id = Column(Integer, ForeignKey("film.film_id"), nullable=False)
+    store_id = Column(Integer, ForeignKey("store.store_id"), nullable=False)
+    last_update = Column(DateTime, nullable=False)
+    film = relationship("Film", back_populates="inventory")
+    store = relationship("Store", back_populates="inventory")
+    rentals = relationship("Rental", back_populates="inventory")
+
+
+class FilmActor(Base):
+    __tablename__ = "film_actor"
+
+    actor_id = Column(Integer, ForeignKey("actor.actor_id"), primary_key=True)
+    film_id = Column(Integer, ForeignKey("film.film_id"), primary_key=True)
+    last_update = Column(DateTime, nullable=False)
+
+
+class FilmCategory(Base):
+    __tablename__ = "film_category"
+
+    film_id = Column(Integer, ForeignKey("film.film_id"), primary_key=True)
+    category_id = Column(SmallInteger, ForeignKey("category.category_id"), primary_key=True)
+    last_update = Column(DateTime, nullable=False)

app/main.py

@@ -0,0 +1,64 @@
+import uvicorn
+from copilotkit import CopilotKitRemoteEndpoint, LangGraphAgent
+from copilotkit.integrations.fastapi import add_fastapi_endpoint
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from .agent.graph import graph
+from .api import insights
+from .db.database import Base, engine
+
+# Create database tables
+Base.metadata.create_all(bind=engine)
+
+app = FastAPI(
+    title="InsightCopilot API", description="API for extracting insights from the Sakila database", version="1.0.0"
+)
+
+# Configure CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # In production, replace with specific origins
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize CopilotKit SDK
+sdk = CopilotKitRemoteEndpoint(
+    agents=[
+        LangGraphAgent(
+            name="insight_copilot_agent",
+            description="A copilot agent that can extract insights from the Sakila database",
+            graph=graph,
+        )
+    ],
+)
+
+# Add CopilotKit endpoint
+add_fastapi_endpoint(app, sdk, "/copilotkit", use_thread_pool=False)
+
+# Include routers
+app.include_router(insights.router, prefix="/api/v1", tags=["insights"])
+
+
+@app.get("/")
+async def root():
+    return {
+        "message": "Welcome to InsightCopilot API",
+        "version": "1.0.0",
+        "docs_url": "/docs",
+        "endpoints": {
+            "insights": {
+                "top_films": "/api/v1/insights/top-films",
+                "category_performance": "/api/v1/insights/category-performance",
+                "customer_activity": "/api/v1/insights/customer-activity",
+                "store_performance": "/api/v1/insights/store-performance",
+                "actor_popularity": "/api/v1/insights/actor-popularity",
+            }
+        },
+    }
+
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000)

app/utils/helpers.py

@@ -0,0 +1,23 @@
+from typing import Any, Dict, List
+
+import pandas as pd
+
+
+def process_data(data: List[Dict[str, Any]]) -> pd.DataFrame:
+    """Convert list of dictionaries to pandas DataFrame."""
+    return pd.DataFrame(data)
+
+
+def generate_sql_query(natural_language_query: str) -> str:
+    """Convert natural language query to SQL query."""
+    # TODO: Implement query generation logic
+    return "SELECT * FROM data LIMIT 10"
+
+
+def format_response(data: pd.DataFrame) -> Dict[str, Any]:
+    """Format DataFrame response for API."""
+    return {
+        "columns": data.columns.tolist(),
+        "data": data.to_dict(orient="records"),
+        "summary": {"row_count": len(data), "column_count": len(data.columns)},
+    }

data/README.txt

@@ -0,0 +1,47 @@
+### Database Description
+The Sakila sample database is a fictitious database designed to represent a DVD rental store. The tables of the database include film, film_category, actor, customer, rental, payment and inventory among others.
+The Sakila sample database is intended to provide a standard schema that can be used for examples in books, tutorials, articles, samples, and so forth.
+Detailed information about the database can be found on the MySQL website: https://dev.mysql.com/doc/sakila/en/
+
+Sakila for SQLite is a part of the sakila-sample-database-ports project intended to provide ported versions of the original MySQL database for other database systems, including:
+
+Oracle
+SQL Server
+SQLIte
+Interbase/Firebird
+Microsoft Access
+
+Sakila for SQLite is a port of the Sakila example database available for MySQL, which was originally developed by Mike Hillyer of the MySQL AB documentation team.
+This project is designed to help database administrators to decide which database to use for development of new products
+The user can run the same SQL against different kind of databases and compare the performance
+
+License: BSD
+Copyright DB Software Laboratory
+http://www.etl-tools.com
+
+Note:
+
+Part of the insert scripts were generated by Advanced ETL Processor
+http://www.etl-tools.com/etl-tools/advanced-etl-processor-enterprise/overview.html
+
+Information about the project and the downloadable files can be found at:
+https://code.google.com/archive/p/sakila-sample-database-ports/
+
+Other versions and developments of the project can be found at:
+https://github.com/ivanceras/sakila/tree/master/sqlite-sakila-db
+
+https://github.com/jOOQ/jOOQ/tree/main/jOOQ-examples/Sakila
+
+Direct access to the MySQL Sakila database, which does not require installation of MySQL (queries can be typed directly in the browser), is provided on the phpMyAdmin demo version website:
+https://demo.phpmyadmin.net/master-config/
+
+### Files Description
+The files in the sqlite-sakila-db folder are the script files which can be used to generate the SQLite version of the database.
+For convenience, the script files have already been run in cmd to generate the sqlite-sakila.db file, as follows:
+
+`sqlite> .open sqlite-sakila.db`   # creates the .db file
+`sqlite> .read sqlite-sakila-schema.sql`   # creates the database schema
+`sqlite> .read sqlite-sakila-insert-data.sql`   # inserts the data
+
+Therefore, the sqlite-sakila.db file can be directly loaded into SQLite3 and queries can be directly executed.
+Note: Data about the film_text table is not provided in the script files, thus the film_text table is empty. Instead the film_id, title and description fields are included in the film table.

data/sqlite-sakila-db/ReadME.txt

@@ -0,0 +1,16 @@
+Sakila for SQLite is a port of the Sakila example database available for MySQL, which was originally developed by Mike Hillyer of the MySQL AB documentation team.
+This project is designed to help database administrators to decide which database to use for development of new products
+The user can run the same SQL against different kind of databases and compare the performance
+
+License: BSD
+Copyright DB Software Laboratory
+http://www.etl-tools.com
+
+Note:
+
+Part of the insert scripts were generated by Advanced ETL Processor
+http://www.etl-tools.com/etl-tools/advanced-etl-processor-enterprise/overview.html
+
+To run SQL sripts use Database browser
+Create new connection and set delimiter to ;
+http://www.etl-tools.com/database-editors/database-browser/overview.html

data/sqlite-sakila-db/sqlite-sakila-delete-data.sql

@@ -0,0 +1,45 @@
+/*
+
+Sakila for SQLite is a port of the Sakila example database available for MySQL, which was originally developed by Mike Hillyer of the MySQL AB documentation team.
+This project is designed to help database administrators to decide which database to use for development of new products
+The user can run the same SQL against different kind of databases and compare the performance
+
+License: BSD
+Copyright DB Software Laboratory
+http://www.etl-tools.com
+
+*/
+
+-- Delete data
+DELETE FROM payment
+;
+DELETE FROM rental
+;
+DELETE FROM customer
+;
+DELETE FROM film_category
+;
+DELETE FROM film_text
+;
+DELETE FROM film_actor
+;
+DELETE FROM inventory
+;
+DELETE FROM film
+;
+DELETE FROM category
+;
+DELETE FROM staff
+;
+DELETE FROM store
+;
+DELETE FROM actor
+;
+DELETE FROM address
+;
+DELETE FROM city
+;
+DELETE FROM country
+;
+DELETE FROM language
+;

data/sqlite-sakila-db/sqlite-sakila-drop-objects.sql

@@ -0,0 +1,68 @@
+/*
+
+Sakila for SQLite is a port of the Sakila example database available for MySQL, which was originally developed by Mike Hillyer of the MySQL AB documentation team.
+This project is designed to help database administrators to decide which database to use for development of new products
+The user can run the same SQL against different kind of databases and compare the performance
+
+License: BSD
+Copyright DB Software Laboratory
+http://www.etl-tools.com
+
+*/
+
+-- Drop Views
+
+DROP VIEW customer_list
+;
+DROP VIEW film_list
+;
+--DROP VIEW nicer_but_slower_film_list;
+DROP VIEW sales_by_film_category
+;
+DROP VIEW sales_by_store
+;
+DROP VIEW staff_list
+;
+
+-- Drop Tables
+
+DROP TABLE payment
+;
+DROP TABLE rental
+;
+DROP TABLE inventory
+;
+DROP TABLE film_text
+;
+DROP TABLE film_category
+;
+DROP TABLE film_actor
+;
+DROP TABLE film
+;
+DROP TABLE language
+;
+DROP TABLE customer
+;
+DROP TABLE actor
+;
+DROP TABLE category
+;
+DROP TABLE store
+;
+DROP TABLE address
+;
+DROP TABLE staff
+;
+DROP TABLE city
+;
+DROP TABLE country
+;
+
+-- Procedures and views
+--drop procedure film_in_stock;
+--drop procedure film_not_in_stock;
+--drop function get_customer_balance;
+--drop function inventory_held_by_customer;
+--drop function inventory_in_stock;
+--drop procedure rewards_report;

data/sqlite-sakila-db/sqlite-sakila-schema.sql

@@ -0,0 +1,644 @@
+/*
+
+Sakila for SQLite is a port of the Sakila example database available for MySQL, which was originally developed by Mike Hillyer of the MySQL AB documentation team.
+This project is designed to help database administrators to decide which database to use for development of new products
+The user can run the same SQL against different kind of databases and compare the performance
+
+License: BSD
+Copyright DB Software Laboratory
+http://www.etl-tools.com
+
+*/
+
+--
+-- Table structure for table actor
+--
+--DROP TABLE actor;
+
+CREATE TABLE actor (
+  actor_id numeric NOT NULL ,
+  first_name VARCHAR(45) NOT NULL,
+  last_name VARCHAR(45) NOT NULL,
+  last_update TIMESTAMP NOT NULL,
+  PRIMARY KEY  (actor_id)
+  )
+  ;
+
+CREATE  INDEX idx_actor_last_name ON actor(last_name)
+;
+
+CREATE TRIGGER actor_trigger_ai AFTER INSERT ON actor
+ BEGIN
+  UPDATE actor SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
+ END
+;
+
+CREATE TRIGGER actor_trigger_au AFTER UPDATE ON actor
+ BEGIN
+  UPDATE actor SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
+ END
+;
+
+ --
+-- Table structure for table country
+--
+
+CREATE TABLE country (
+  country_id SMALLINT NOT NULL,
+  country VARCHAR(50) NOT NULL,
+  last_update TIMESTAMP,
+  PRIMARY KEY  (country_id)
+)
+;
+
+CREATE TRIGGER country_trigger_ai AFTER INSERT ON country
+ BEGIN
+  UPDATE country SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
+ END
+;
+
+CREATE TRIGGER country_trigger_au AFTER UPDATE ON country
+ BEGIN
+  UPDATE country SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
+ END
+;
+
+--
+-- Table structure for table city
+--
+
+CREATE TABLE city (
+  city_id int NOT NULL,
+  city VARCHAR(50) NOT NULL,
+  country_id SMALLINT NOT NULL,
+  last_update TIMESTAMP NOT NULL,
+  PRIMARY KEY  (city_id),
+  CONSTRAINT fk_city_country FOREIGN KEY (country_id) REFERENCES country (country_id) ON DELETE NO ACTION ON UPDATE CASCADE
+)
+;
+CREATE  INDEX idx_fk_country_id ON city(country_id)
+;
+
+CREATE TRIGGER city_trigger_ai AFTER INSERT ON city
+ BEGIN
+  UPDATE city SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
+ END
+;
+
+CREATE TRIGGER city_trigger_au AFTER UPDATE ON city
+ BEGIN
+  UPDATE city SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
+ END
+;
+
+--
+-- Table structure for table address
+--
+
+CREATE TABLE address (
+  address_id int NOT NULL,
+  address VARCHAR(50) NOT NULL,
+  address2 VARCHAR(50) DEFAULT NULL,
+  district VARCHAR(20) NOT NULL,
+  city_id INT  NOT NULL,
+  postal_code VARCHAR(10) DEFAULT NULL,
+  phone VARCHAR(20) NOT NULL,
+  last_update TIMESTAMP NOT NULL,
+  PRIMARY KEY  (address_id),
+  CONSTRAINT fk_address_city FOREIGN KEY (city_id) REFERENCES city (city_id) ON DELETE NO ACTION ON UPDATE CASCADE
+)
+;
+
+CREATE  INDEX idx_fk_city_id ON address(city_id)
+;
+
+CREATE TRIGGER address_trigger_ai AFTER INSERT ON address
+ BEGIN
+  UPDATE address SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
+ END
+;
+
+CREATE TRIGGER address_trigger_au AFTER UPDATE ON address
+ BEGIN
+  UPDATE address SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
+ END
+;
+
+--
+-- Table structure for table language
+--
+
+CREATE TABLE language (
+  language_id SMALLINT NOT NULL ,
+  name CHAR(20) NOT NULL,
+  last_update TIMESTAMP NOT NULL,
+  PRIMARY KEY (language_id)
+)
+;
+
+CREATE TRIGGER language_trigger_ai AFTER INSERT ON language
+ BEGIN
+  UPDATE language SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
+ END
+;
+
+CREATE TRIGGER language_trigger_au AFTER UPDATE ON language
+ BEGIN
+  UPDATE language SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
+ END
+;
+
+--
+-- Table structure for table category
+--
+
+CREATE TABLE category (
+  category_id SMALLINT NOT NULL,
+  name VARCHAR(25) NOT NULL,
+  last_update TIMESTAMP NOT NULL,
+  PRIMARY KEY  (category_id)
+);
+
+CREATE TRIGGER category_trigger_ai AFTER INSERT ON category
+ BEGIN
+  UPDATE category SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
+ END
+;
+
+CREATE TRIGGER category_trigger_au AFTER UPDATE ON category
+ BEGIN
+  UPDATE category SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
+ END
+;
+
+--
+-- Table structure for table customer
+--
+
+CREATE TABLE customer (
+  customer_id INT NOT NULL,
+  store_id INT NOT NULL,
+  first_name VARCHAR(45) NOT NULL,
+  last_name VARCHAR(45) NOT NULL,
+  email VARCHAR(50) DEFAULT NULL,
+  address_id INT NOT NULL,
+  active CHAR(1) DEFAULT 'Y' NOT NULL,
+  create_date TIMESTAMP NOT NULL,
+  last_update TIMESTAMP NOT NULL,
+  PRIMARY KEY  (customer_id),
+  CONSTRAINT fk_customer_store FOREIGN KEY (store_id) REFERENCES store (store_id) ON DELETE NO ACTION ON UPDATE CASCADE,
+  CONSTRAINT fk_customer_address FOREIGN KEY (address_id) REFERENCES address (address_id) ON DELETE NO ACTION ON UPDATE CASCADE
+)
+;
+
+CREATE  INDEX idx_customer_fk_store_id ON customer(store_id)
+;
+CREATE  INDEX idx_customer_fk_address_id ON customer(address_id)
+;
+CREATE  INDEX idx_customer_last_name ON customer(last_name)
+;
+
+CREATE TRIGGER customer_trigger_ai AFTER INSERT ON customer
+ BEGIN
+  UPDATE customer SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
+ END
+;
+
+CREATE TRIGGER customer_trigger_au AFTER UPDATE ON customer
+ BEGIN
+  UPDATE customer SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
+ END
+;
+
+--
+-- Table structure for table film
+--
+
+CREATE TABLE film (
+  film_id int NOT NULL,
+  title VARCHAR(255) NOT NULL,
+  description BLOB SUB_TYPE TEXT DEFAULT NULL,
+  release_year VARCHAR(4) DEFAULT NULL,
+  language_id SMALLINT NOT NULL,
+  original_language_id SMALLINT DEFAULT NULL,
+  rental_duration SMALLINT  DEFAULT 3 NOT NULL,
+  rental_rate DECIMAL(4,2) DEFAULT 4.99 NOT NULL,
+  length SMALLINT DEFAULT NULL,
+  replacement_cost DECIMAL(5,2) DEFAULT 19.99 NOT NULL,
+  rating VARCHAR(10) DEFAULT 'G',
+  special_features VARCHAR(100) DEFAULT NULL,
+  last_update TIMESTAMP NOT NULL,
+  PRIMARY KEY  (film_id),
+  CONSTRAINT CHECK_special_features CHECK(special_features is null or
+                                                           special_features like '%Trailers%' or
+                                                           special_features like '%Commentaries%' or
+                                                           special_features like '%Deleted Scenes%' or
+                                                           special_features like '%Behind the Scenes%'),
+  CONSTRAINT CHECK_special_rating CHECK(rating in ('G','PG','PG-13','R','NC-17')),
+  CONSTRAINT fk_film_language FOREIGN KEY (language_id) REFERENCES language (language_id) ,
+  CONSTRAINT fk_film_language_original FOREIGN KEY (original_language_id) REFERENCES language (language_id)
+)
+;
+CREATE  INDEX idx_fk_language_id ON film(language_id)
+;
+CREATE  INDEX idx_fk_original_language_id ON film(original_language_id)
+;
+
+CREATE TRIGGER film_trigger_ai AFTER INSERT ON film
+ BEGIN
+  UPDATE film SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
+ END
+;
+
+CREATE TRIGGER film_trigger_au AFTER UPDATE ON film
+ BEGIN
+  UPDATE film SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
+ END
+;
+
+--
+-- Table structure for table film_actor
+--
+
+CREATE TABLE film_actor (
+  actor_id INT NOT NULL,
+  film_id  INT NOT NULL,
+  last_update TIMESTAMP NOT NULL,
+  PRIMARY KEY  (actor_id,film_id),
+  CONSTRAINT fk_film_actor_actor FOREIGN KEY (actor_id) REFERENCES actor (actor_id) ON DELETE NO ACTION ON UPDATE CASCADE,
+  CONSTRAINT fk_film_actor_film FOREIGN KEY (film_id) REFERENCES film (film_id) ON DELETE NO ACTION ON UPDATE CASCADE
+)
+;
+
+CREATE  INDEX idx_fk_film_actor_film ON film_actor(film_id)
+;
+
+CREATE  INDEX idx_fk_film_actor_actor ON film_actor(actor_id)
+;
+
+CREATE TRIGGER film_actor_trigger_ai AFTER INSERT ON film_actor
+ BEGIN
+  UPDATE film_actor SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
+ END
+;
+
+CREATE TRIGGER film_actor_trigger_au AFTER UPDATE ON film_actor
+ BEGIN
+  UPDATE film_actor SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
+ END
+;
+
+
+--
+-- Table structure for table film_category
+--
+
+CREATE TABLE film_category (
+  film_id INT NOT NULL,
+  category_id SMALLINT  NOT NULL,
+  last_update TIMESTAMP NOT NULL,
+  PRIMARY KEY (film_id, category_id),
+  CONSTRAINT fk_film_category_film FOREIGN KEY (film_id) REFERENCES film (film_id) ON DELETE NO ACTION ON UPDATE CASCADE,
+  CONSTRAINT fk_film_category_category FOREIGN KEY (category_id) REFERENCES category (category_id) ON DELETE NO ACTION ON UPDATE CASCADE
+)
+;
+
+CREATE  INDEX idx_fk_film_category_film ON film_category(film_id)
+;
+
+CREATE  INDEX idx_fk_film_category_category ON film_category(category_id)
+;
+
+CREATE TRIGGER film_category_trigger_ai AFTER INSERT ON film_category
+ BEGIN
+  UPDATE film_category SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
+ END
+;
+
+CREATE TRIGGER film_category_trigger_au AFTER UPDATE ON film_category
+ BEGIN
+  UPDATE film_category SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
+ END
+;
+
+--
+-- Table structure for table film_text
+--
+
+CREATE TABLE film_text (
+  film_id SMALLINT NOT NULL,
+  title VARCHAR(255) NOT NULL,
+  description BLOB SUB_TYPE TEXT,
+  PRIMARY KEY  (film_id)
+)
+;
+
+--
+-- Table structure for table inventory
+--
+
+CREATE TABLE inventory (
+  inventory_id INT NOT NULL,
+  film_id INT NOT NULL,
+  store_id INT NOT NULL,
+  last_update TIMESTAMP NOT NULL,
+  PRIMARY KEY  (inventory_id),
+  CONSTRAINT fk_inventory_store FOREIGN KEY (store_id) REFERENCES store (store_id) ON DELETE NO ACTION ON UPDATE CASCADE,
+  CONSTRAINT fk_inventory_film FOREIGN KEY (film_id) REFERENCES film (film_id) ON DELETE NO ACTION ON UPDATE CASCADE
+)
+;
+
+CREATE  INDEX idx_fk_film_id ON inventory(film_id)
+;
+
+CREATE  INDEX idx_fk_film_id_store_id ON inventory(store_id,film_id)
+;
+
+CREATE TRIGGER inventory_trigger_ai AFTER INSERT ON inventory
+ BEGIN
+  UPDATE inventory SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
+ END
+;
+
+CREATE TRIGGER inventory_trigger_au AFTER UPDATE ON inventory
+ BEGIN
+  UPDATE inventory SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
+ END
+;
+
+--
+-- Table structure for table staff
+--
+
+CREATE TABLE staff (
+  staff_id SMALLINT NOT NULL,
+  first_name VARCHAR(45) NOT NULL,
+  last_name VARCHAR(45) NOT NULL,
+  address_id INT NOT NULL,
+  picture BLOB DEFAULT NULL,
+  email VARCHAR(50) DEFAULT NULL,
+  store_id INT NOT NULL,
+  active SMALLINT DEFAULT 1 NOT NULL,
+  username VARCHAR(16) NOT NULL,
+  password VARCHAR(40) DEFAULT NULL,
+  last_update TIMESTAMP NOT NULL,
+  PRIMARY KEY  (staff_id),
+  CONSTRAINT fk_staff_store FOREIGN KEY (store_id) REFERENCES store (store_id) ON DELETE NO ACTION ON UPDATE CASCADE,
+  CONSTRAINT fk_staff_address FOREIGN KEY (address_id) REFERENCES address (address_id) ON DELETE NO ACTION ON UPDATE CASCADE
+)
+;
+CREATE  INDEX idx_fk_staff_store_id ON staff(store_id)
+;
+
+CREATE  INDEX idx_fk_staff_address_id ON staff(address_id)
+;
+
+CREATE TRIGGER staff_trigger_ai AFTER INSERT ON staff
+ BEGIN
+  UPDATE staff SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
+ END
+;
+
+CREATE TRIGGER staff_trigger_au AFTER UPDATE ON staff
+ BEGIN
+  UPDATE staff SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
+ END
+;
+
+--
+-- Table structure for table store
+--
+
+CREATE TABLE store (
+  store_id INT NOT NULL,
+  manager_staff_id SMALLINT NOT NULL,
+  address_id INT NOT NULL,
+  last_update TIMESTAMP NOT NULL,
+  PRIMARY KEY  (store_id),
+  CONSTRAINT fk_store_staff FOREIGN KEY (manager_staff_id) REFERENCES staff (staff_id) ,
+  CONSTRAINT fk_store_address FOREIGN KEY (address_id) REFERENCES address (address_id)
+)
+;
+
+CREATE  INDEX idx_store_fk_manager_staff_id ON store(manager_staff_id)
+;
+
+CREATE  INDEX idx_fk_store_address ON store(address_id)
+;
+
+CREATE TRIGGER store_trigger_ai AFTER INSERT ON store
+ BEGIN
+  UPDATE store SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
+ END
+;
+
+CREATE TRIGGER store_trigger_au AFTER UPDATE ON store
+ BEGIN
+  UPDATE store SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
+ END
+;
+
+--
+-- Table structure for table payment
+--
+
+CREATE TABLE payment (
+  payment_id int NOT NULL,
+  customer_id INT  NOT NULL,
+  staff_id SMALLINT NOT NULL,
+  rental_id INT DEFAULT NULL,
+  amount DECIMAL(5,2) NOT NULL,
+  payment_date TIMESTAMP NOT NULL,
+  last_update TIMESTAMP NOT NULL,
+  PRIMARY KEY  (payment_id),
+  CONSTRAINT fk_payment_rental FOREIGN KEY (rental_id) REFERENCES rental (rental_id) ON DELETE SET NULL ON UPDATE CASCADE,
+  CONSTRAINT fk_payment_customer FOREIGN KEY (customer_id) REFERENCES customer (customer_id) ,
+  CONSTRAINT fk_payment_staff FOREIGN KEY (staff_id) REFERENCES staff (staff_id)
+)
+;
+CREATE  INDEX idx_fk_staff_id ON payment(staff_id)
+;
+CREATE  INDEX idx_fk_customer_id ON payment(customer_id)
+;
+
+CREATE TRIGGER payment_trigger_ai AFTER INSERT ON payment
+ BEGIN
+  UPDATE payment SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
+ END
+;
+
+CREATE TRIGGER payment_trigger_au AFTER UPDATE ON payment
+ BEGIN
+  UPDATE payment SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
+ END
+;
+
+CREATE TABLE rental (
+  rental_id INT NOT NULL,
+  rental_date TIMESTAMP NOT NULL,
+  inventory_id INT  NOT NULL,
+  customer_id INT  NOT NULL,
+  return_date TIMESTAMP DEFAULT NULL,
+  staff_id SMALLINT  NOT NULL,
+  last_update TIMESTAMP NOT NULL,
+  PRIMARY KEY (rental_id),
+  CONSTRAINT fk_rental_staff FOREIGN KEY (staff_id) REFERENCES staff (staff_id) ,
+  CONSTRAINT fk_rental_inventory FOREIGN KEY (inventory_id) REFERENCES inventory (inventory_id) ,
+  CONSTRAINT fk_rental_customer FOREIGN KEY (customer_id) REFERENCES customer (customer_id)
+)
+;
+CREATE INDEX idx_rental_fk_inventory_id ON rental(inventory_id)
+;
+CREATE INDEX idx_rental_fk_customer_id ON rental(customer_id)
+;
+CREATE INDEX idx_rental_fk_staff_id ON rental(staff_id)
+;
+CREATE UNIQUE INDEX   idx_rental_uq  ON rental (rental_date,inventory_id,customer_id)
+;
+
+CREATE TRIGGER rental_trigger_ai AFTER INSERT ON rental
+ BEGIN
+  UPDATE rental SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
+ END
+;
+
+CREATE TRIGGER rental_trigger_au AFTER UPDATE ON rental
+ BEGIN
+  UPDATE rental SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
+ END
+;
+--
+-- View structure for view customer_list
+--
+
+CREATE VIEW customer_list
+AS
+SELECT cu.customer_id AS ID,
+       cu.first_name||' '||cu.last_name AS name,
+       a.address AS address,
+       a.postal_code AS zip_code,
+       a.phone AS phone,
+       city.city AS city,
+       country.country AS country,
+       case when cu.active=1 then 'active' else '' end AS notes,
+       cu.store_id AS SID
+FROM customer AS cu JOIN address AS a ON cu.address_id = a.address_id JOIN city ON a.city_id = city.city_id
+    JOIN country ON city.country_id = country.country_id
+;
+--
+-- View structure for view film_list
+--
+
+CREATE VIEW film_list
+AS
+SELECT film.film_id AS FID,
+       film.title AS title,
+       film.description AS description,
+       category.name AS category,
+       film.rental_rate AS price,
+       film.length AS length,
+       film.rating AS rating,
+       actor.first_name||' '||actor.last_name AS actors
+FROM category LEFT JOIN film_category ON category.category_id = film_category.category_id LEFT JOIN film ON film_category.film_id = film.film_id
+        JOIN film_actor ON film.film_id = film_actor.film_id
+    JOIN actor ON film_actor.actor_id = actor.actor_id
+;
+
+--
+-- View structure for view staff_list
+--
+
+CREATE VIEW staff_list
+AS
+SELECT s.staff_id AS ID,
+       s.first_name||' '||s.last_name AS name,
+       a.address AS address,
+       a.postal_code AS zip_code,
+       a.phone AS phone,
+       city.city AS city,
+       country.country AS country,
+       s.store_id AS SID
+FROM staff AS s JOIN address AS a ON s.address_id = a.address_id JOIN city ON a.city_id = city.city_id
+    JOIN country ON city.country_id = country.country_id
+;
+--
+-- View structure for view sales_by_store
+--
+
+CREATE VIEW sales_by_store
+AS
+SELECT
+  s.store_id
+ ,c.city||','||cy.country AS store
+ ,m.first_name||' '||m.last_name AS manager
+ ,SUM(p.amount) AS total_sales
+FROM payment AS p
+INNER JOIN rental AS r ON p.rental_id = r.rental_id
+INNER JOIN inventory AS i ON r.inventory_id = i.inventory_id
+INNER JOIN store AS s ON i.store_id = s.store_id
+INNER JOIN address AS a ON s.address_id = a.address_id
+INNER JOIN city AS c ON a.city_id = c.city_id
+INNER JOIN country AS cy ON c.country_id = cy.country_id
+INNER JOIN staff AS m ON s.manager_staff_id = m.staff_id
+GROUP BY
+  s.store_id
+, c.city||','||cy.country
+, m.first_name||' '||m.last_name
+;
+--
+-- View structure for view sales_by_film_category
+--
+-- Note that total sales will add up to >100% because
+-- some titles belong to more than 1 category
+--
+
+CREATE VIEW sales_by_film_category
+AS
+SELECT
+c.name AS category
+, SUM(p.amount) AS total_sales
+FROM payment AS p
+INNER JOIN rental AS r ON p.rental_id = r.rental_id
+INNER JOIN inventory AS i ON r.inventory_id = i.inventory_id
+INNER JOIN film AS f ON i.film_id = f.film_id
+INNER JOIN film_category AS fc ON f.film_id = fc.film_id
+INNER JOIN category AS c ON fc.category_id = c.category_id
+GROUP BY c.name
+;
+
+--
+-- View structure for view actor_info
+--
+
+/*
+CREATE VIEW actor_info
+AS
+SELECT
+a.actor_id,
+a.first_name,
+a.last_name,
+GROUP_CONCAT(DISTINCT CONCAT(c.name, ': ',
+        (SELECT GROUP_CONCAT(f.title ORDER BY f.title SEPARATOR ', ')
+                    FROM sakila.film f
+                    INNER JOIN sakila.film_category fc
+                      ON f.film_id = fc.film_id
+                    INNER JOIN sakila.film_actor fa
+                      ON f.film_id = fa.film_id
+                    WHERE fc.category_id = c.category_id
+                    AND fa.actor_id = a.actor_id
+                 )
+             )
+             ORDER BY c.name SEPARATOR '; ')
+AS film_info
+FROM sakila.actor a
+LEFT JOIN sakila.film_actor fa
+  ON a.actor_id = fa.actor_id
+LEFT JOIN sakila.film_category fc
+  ON fa.film_id = fc.film_id
+LEFT JOIN sakila.category c
+  ON fc.category_id = c.category_id
+GROUP BY a.actor_id, a.first_name, a.last_name;
+*/
+
+-- TO DO PROCEDURES
+-- TO DO TRIGGERS

package-lock.json

@@ -0,0 +1,6 @@
+{
+  "name": "backend",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}

pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "insight-copilot"
+version = "0.1.0"
+description = "A modular, open-source Co-Pilot app built with LangGraph and CopilotKit"
+dependencies = [
+    "fastapi>=0.68.0",
+    "uvicorn>=0.15.0",
+    "sqlalchemy>=1.4.0",
+    "pandas>=1.3.0",
+    "langchain>=0.0.200",
+    "langgraph>=0.0.10",
+    "python-dotenv>=0.19.0",
+    "pydantic>=1.8.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["app"]
+
+[tool.ruff]
+line-length = 88
+target-version = "py39"

requirements.txt

@@ -0,0 +1,11 @@
+fastapi==0.115.12
+uvicorn==0.34.2
+sqlalchemy==2.0.40
+pandas==2.2.3
+langchain==0.3.25
+langgraph==0.4.3
+python-dotenv==1.1.0
+pydantic==2.11.4
+copilotkit==0.1.45
+langchain-openai==0.3.16
+ipython==9.2.0