LangChain

LangChain tools for Hotdata — give your chains and agents SQL execution and managed database access.

Install

pip install hotdata-langchain

Authentication

Set HOTDATA_API_KEY in your environment. Optionally set HOTDATA_WORKSPACE to pin a specific workspace.

Quickstart

from hotdata_runtime import from_env
from hotdata_langchain import make_hotdata_tools
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_core.prompts import ChatPromptTemplate

client = from_env()
tools = make_hotdata_tools(client)

llm = ChatOpenAI(model="gpt-4o")
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a data analyst."),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

agent = create_tool_calling_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
result = executor.invoke({"input": "How many orders are in the database?"})
print(result["output"])

Tools

make_hotdata_tools returns four StructuredTool objects ready to pass to any LangChain agent:

Tool	Description
`hotdata_execute_sql`	Run SQL and return JSON rows
`hotdata_list_managed_databases`	List Hotdata-managed databases
`hotdata_create_managed_database`	Create a database and declare tables
`hotdata_load_managed_table`	Load a local parquet file into a table

tools = make_hotdata_tools(
    client,
    max_rows=50,   # rows returned to the agent per query (default 100)
    database=None, # pin to a specific database id (optional)
)

Run SQL directly

from hotdata_langchain import execute_sql_json, result_rows_for_llm

# Returns a JSON string — useful for custom tool wrappers
json_str = execute_sql_json(client, "SELECT * FROM orders LIMIT 5")

# Returns list[dict] from a QueryResult, trimmed to max_rows
result = client.execute_sql("SELECT * FROM orders LIMIT 100")
rows = result_rows_for_llm(result, max_rows=20)

Managed databases

from hotdata_langchain.databases import (
    create_managed_database,
    list_managed_databases_json,
    load_managed_table,
)

# Create a database and declare tables
db = create_managed_database(
    client,
    name="sales",
    schema="public",
    tables=["orders", "customers"],
)

# Load a local parquet file into a declared table
loaded = load_managed_table(
    client,
    database=db.id,
    table="orders",
    file="orders.parquet",
)
print(f"Loaded {loaded.row_count} rows → {loaded.full_name}")