Loading from databases in LangChain - Mini Project: Build & Apply

Loading Data from a Database with LangChain

📖 Scenario: You are building a simple app that fetches data from a database to use with LangChain. This helps you get information ready for your language model to understand.

🎯 Goal: Learn how to connect to a database, configure a query, load data using LangChain's database loader, and prepare it for further processing.

📋 What You'll Learn

Create a database connection string variable

Set up a SQL query string variable

Use LangChain's SQLDatabase and SQLDatabaseChain to load data

Complete the setup to run the database query and load results

💡 Why This Matters

🌍 Real World

Loading data from databases is common when building apps that use language models to understand or analyze real data stored in databases.

💼 Career

Many jobs require connecting language models to databases to automate data retrieval, reporting, or building intelligent assistants.

1

Create the database connection string

Create a variable called connection_string and set it to the exact value "sqlite:///example.db".

LangChain

# Your code here

Hint

This string tells LangChain where your database is located. Use the exact text including quotes.

2

Set up the SQL query string

Create a variable called query and set it to the exact SQL query string "SELECT * FROM users".

LangChain

connection_string = "sqlite:///example.db"
# Your code here

Hint

This query will select all data from the users table in your database.

3

Load data using LangChain's SQLDatabase

Import SQLDatabase from langchain_sql_database and create a variable called db by calling SQLDatabase.from_uri(connection_string).

LangChain

connection_string = "sqlite:///example.db"
query = "SELECT * FROM users"
# Your code here

Hint

Use the exact import and method call to create the database object.

4

Create the SQLDatabaseChain and run the query

Import SQLDatabaseChain from langchain_chains. Then create a variable called db_chain by calling SQLDatabaseChain(database=db, query=query).

LangChain

from langchain_sql_database import SQLDatabase

connection_string = "sqlite:///example.db"
query = "SELECT * FROM users"
db = SQLDatabase.from_uri(connection_string)
# Your code here

Hint

This sets up the chain that will run your SQL query using LangChain.

Practice

1. What is the main purpose of using SQLDatabaseLoader in Langchain?

easy

A. To create a new database schema

B. To load data from a database using a SQL query

C. To save data into a database

D. To visualize database tables

Solution

1. Step 1: Understand the role of SQLDatabaseLoader

   It is designed to connect to a database and fetch data using SQL queries.

2. Step 2: Compare options with the purpose

   Only To load data from a database using a SQL query describes loading data from a database, which matches the loader's function.

3. Final Answer:

   To load data from a database using a SQL query -> Option B

4. Quick Check:

   Loading data = SQLDatabaseLoader usage [OK]

Hint: Loader means fetching data, not saving or creating [OK]

Common Mistakes:

• Confusing loading with saving data
• Thinking it creates database schemas
• Assuming it visualizes data

2. Which of the following is the correct way to initialize SQLDatabaseLoader with a database URI and a query?

easy

A. loader = SQLDatabaseLoader(query='sqlite:///mydb.db', uri='SELECT * FROM users')

B. loader = SQLDatabaseLoader('SELECT * FROM users', 'sqlite:///mydb.db')

C. loader = SQLDatabaseLoader(uri='sqlite:///mydb.db', query='SELECT * FROM users')

D. loader = SQLDatabaseLoader('mydb.db', 'SELECT * FROM users')

Solution

1. Step 1: Recall the parameter order and names

   The correct syntax uses named parameters: uri for the database URI and query for the SQL query.

2. Step 2: Match options with correct parameter usage

   Only loader = SQLDatabaseLoader(uri='sqlite:///mydb.db', query='SELECT * FROM users') correctly uses named parameters with proper values.

3. Final Answer:

   loader = SQLDatabaseLoader(uri='sqlite:///mydb.db', query='SELECT * FROM users') -> Option C

4. Quick Check:

   Named parameters uri and query = loader = SQLDatabaseLoader(uri='sqlite:///mydb.db', query='SELECT * FROM users') [OK]

Hint: Use named parameters uri and query in correct order [OK]

Common Mistakes:

• Swapping uri and query parameters
• Using positional arguments in wrong order
• Missing parameter names

3. Given the code below, what will be the output type of data after loading?

loader = SQLDatabaseLoader(uri='sqlite:///example.db', query='SELECT name FROM employees')
data = loader.load()

medium

A. A list of documents representing rows

B. A single string with all names concatenated

C. A dictionary with column names as keys

D. An integer count of rows

Solution

1. Step 1: Understand what loader.load() returns

   It returns a list of document objects, each representing a row from the query result.

2. Step 2: Compare output types

   Only A list of documents representing rows matches the expected list of documents; others describe different data types.

3. Final Answer:

   A list of documents representing rows -> Option A

4. Quick Check:

   load() returns list of documents [OK]

Hint: load() returns list of documents, not strings or dicts [OK]

Common Mistakes:

• Expecting a single string instead of list
• Thinking output is a dictionary
• Assuming it returns row count

4. Identify the error in the following code snippet for loading data from a database:

loader = SQLDatabaseLoader(uri='postgresql://user:pass@localhost/db', query='SELECT * FROM')
data = loader.load()

medium

A. The URI format is incorrect for PostgreSQL

B. The loader class name is misspelled

C. The load() method is missing parentheses

D. The SQL query is incomplete and will cause a syntax error

Solution

1. Step 1: Check the SQL query syntax

   The query 'SELECT * FROM' is incomplete because it lacks a table name, causing a syntax error.

2. Step 2: Verify other parts

   The URI format is correct, load() has parentheses, and class name is spelled correctly.

3. Final Answer:

   The SQL query is incomplete and will cause a syntax error -> Option D

4. Quick Check:

   Incomplete SQL query = syntax error [OK]

Hint: Check SQL query completeness first [OK]

Common Mistakes:

• Ignoring incomplete SQL query
• Misreading URI format
• Forgetting parentheses on load()

5. You want to load only active users from a database using Langchain's SQLDatabaseLoader. Which query and loader setup correctly filters active users assuming the table is users with a boolean column is_active?

hard

A. loader = SQLDatabaseLoader(uri='sqlite:///app.db', query='SELECT * FROM users WHERE is_active = 1')

B. loader = SQLDatabaseLoader(uri='sqlite:///app.db', query='SELECT * FROM users WHERE is_active')

C. loader = SQLDatabaseLoader(uri='sqlite:///app.db', query='SELECT * FROM users WHERE is_active = 'true'')

D. loader = SQLDatabaseLoader(uri='sqlite:///app.db', query='SELECT * FROM users WHERE active = true')

Solution

1. Step 1: Understand SQL boolean filtering in SQLite

   SQLite uses 1 for true and 0 for false in boolean columns.

2. Step 2: Evaluate each query for correctness

   loader = SQLDatabaseLoader(uri='sqlite:///app.db', query='SELECT * FROM users WHERE is_active = 1') correctly uses 'is_active = 1'. loader = SQLDatabaseLoader(uri='sqlite:///app.db', query='SELECT * FROM users WHERE is_active') is incomplete, C has wrong quotes, D uses wrong column name.

3. Final Answer:

   loader = SQLDatabaseLoader(uri='sqlite:///app.db', query='SELECT * FROM users WHERE is_active = 1') -> Option A

4. Quick Check:

   Boolean true in SQLite = 1 [OK]

Hint: Use 'is_active = 1' for true in SQLite queries [OK]

Common Mistakes:

• Using wrong column name 'active'
• Incorrect SQL syntax for boolean values
• Missing comparison operator in WHERE clause