LangChain SQLDatabaseChain vs DataSpoc Lens: ¿Cuál Es Mejor para Consultas de Datos?

from langchain_community.utilities import SQLDatabase
from langchain_openai import ChatOpenAI
from langchain.chains import create_sql_query_chain
from langchain_community.tools.sql_database.tool import QuerySQLDataBaseTool

# 1. Connect to your database
db = SQLDatabase.from_uri(
    "postgresql://user:password@host:5432/analytics",
    include_tables=["orders", "customers", "products"],  # limit scope
    sample_rows_in_table_info=3,  # include sample rows in schema prompt
)

# 2. Create LLM
llm = ChatOpenAI(model="gpt-4o", temperature=0)

# 3. Create the chain
query_chain = create_sql_query_chain(llm, db)
execute_tool = QuerySQLDataBaseTool(db=db)

# 4. Ask a question
sql = query_chain.invoke({"question": "What were total sales by region last quarter?"})
print(f"Generated SQL: {sql}")

result = execute_tool.invoke(sql)
print(f"Result: {result}")

from dataspoc_lens import LensClient

lens = LensClient()  # reads config from ~/.dataspoc/config.yaml or env vars

# List what's available
print(lens.tables())
# ['raw_orders', 'raw_customers', 'curated_sales', 'gold_revenue']

# Ask a question (natural language → SQL → execute → result)
answer = lens.ask("What were total sales by region last quarter?")
print(answer)

# Or write SQL directly
df = lens.query("""
    SELECT region, SUM(amount) as total_sales
    FROM curated_sales
    WHERE sale_date >= '2026-01-01'
    GROUP BY region
    ORDER BY total_sales DESC
""")
print(df)

# LangChain
print(db.get_usable_table_names())
# Requires active DB connection

# DataSpoc Lens
print(lens.tables())
# Reads from bucket manifest — no database needed

# LangChain
print(db.get_table_info(table_names=["orders"]))
# Returns CREATE TABLE + sample rows (sent to LLM as context)

# DataSpoc Lens
print(lens.schema("raw_orders"))
# Returns column names and types as a dict

# LangChain
chain = create_sql_query_chain(llm, db)
sql = chain.invoke({"question": "Top 5 customers by lifetime value"})
result = execute_tool.invoke(sql)

# DataSpoc Lens
answer = lens.ask("Top 5 customers by lifetime value")

# LangChain
result = db.run("SELECT customer_id, SUM(amount) FROM orders GROUP BY 1 ORDER BY 2 DESC LIMIT 5")

# DataSpoc Lens
df = lens.query("SELECT customer_id, SUM(amount) FROM raw_orders GROUP BY 1 ORDER BY 2 DESC LIMIT 5")
# Returns a pandas DataFrame, not a string

# LangChain — define as a tool
from langchain.agents import create_openai_tools_agent, AgentExecutor
from langchain.tools import Tool

tools = [
    Tool(name="query_db", func=execute_tool.invoke, description="Run SQL"),
    Tool(name="list_tables", func=db.get_usable_table_names, description="List tables"),
]
agent = create_openai_tools_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools)
executor.invoke({"input": "Analyze sales trends"})

# DataSpoc Lens — native MCP server
# No code needed. Just configure the MCP server:
# dataspoc-lens mcp
# Any MCP-compatible agent (Claude, Cursor, etc.) connects directly.

# LangChain excels at ad-hoc DB access
from langchain_community.utilities import SQLDatabase

# Connect to your production read replica
db = SQLDatabase.from_uri("postgresql://readonly:pass@replica:5432/prod")

# Lens excels at data lake access
from dataspoc_lens import LensClient

lens = LensClient()
# Data comes from Parquet in your bucket — no DB needed
df = lens.query("SELECT * FROM curated_sales WHERE region = 'EMEA' LIMIT 100")

import json
from openai import OpenAI
from langchain_community.utilities import SQLDatabase
from dataspoc_lens import LensClient

openai_client = OpenAI()
db = SQLDatabase.from_uri("postgresql://readonly:pass@host:5432/app")
lens = LensClient()

TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "query_app_db",
            "description": "Query the application database (users, sessions, settings).",
            "parameters": {
                "type": "object",
                "properties": {"sql": {"type": "string"}},
                "required": ["sql"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "query_data_lake",
            "description": "Query the data lake (sales, events, analytics).",
            "parameters": {
                "type": "object",
                "properties": {"sql": {"type": "string"}},
                "required": ["sql"],
            },
        },
    },
]


def dispatch(name, args):
    if name == "query_app_db":
        return db.run(args["sql"])
    elif name == "query_data_lake":
        df = lens.query(args["sql"])
        return df.to_json(orient="records")