Welcome to the future of data querying! If you’ve ever wished for a simpler way to extract insights from your database using natural language, you’re in the right place. In this blog post, we will walk you through how to use db-ally, an LLM-powered library designed to streamline the process of querying structured data.

What is db-ally?

db-ally is a powerful library that allows developers to create natural language interfaces for data querying. Unlike text-to-SQL solutions, db-ally focuses on specific use cases and defines predictable behaviors, making it less complex and more secure.

Key Features of db-ally

• Consistency: Output formats are predictable, resulting in better controllability for developers.
• Security: It restricts direct database access, ensuring system safety.
• Efficiency: Most underlying database complexities are hidden, enabling high performance.
• Portability: It offers an abstraction layer that supports integration with various database technologies.

Quick Start Guide

To get started with db-ally, follow these concise steps:

1. First, install db-ally by running the following command in your terminal:

pip install dbally

2. If you need specific features, you can also add extensions:

pip install dbally[litellm,faiss,langsmith]

3. Define your data retrieval use case by creating views, filters, and aggregations. This is where we touch on our code analogy:

Understanding db-ally with an Analogy

Think of db-ally as a well-structured shopping mall instead of a busy street market. In this mall, each store represents a specific data query you can make. The stores are organized (like views), and there are clear signs (filters) directing you to what you can buy. You wouldn’t want to wander aimlessly through the chaotic street market (traditional querying), trying to figure out where each specialty store is or what they sell. Instead, db-ally guides you straightforwardly, ensuring you get exactly what you’re looking for while keeping your experience safe and secure.

Setting Up an Example

Here’s a basic implementation of a db-ally view for an HR application that retrieves candidates from an SQL database:

from dbally import decorators, SqlAlchemyBaseView, create_collection
from dbally.llms.litellm import LiteLLM
from sqlalchemy import create_engine

class CandidateView(SqlAlchemyBaseView):
    """A view for retrieving candidates from the database."""
    
    def get_select(self):
        """Defines which columns to select."""
        return sqlalchemy.select(Candidate.id, Candidate.name, Candidate.country)

    @decorators.view_filter()
    def from_country(self, country: str):
        """Filter candidates from a specific country."""
        return Candidate.country == country

llm = LiteLLM(model_name='gpt-3.5-turbo')
engine = create_engine('sqlite:examples/recruiting_data/candidates.db')
my_collection = create_collection(collection_name, llm)
my_collection.add(CandidateView, lambda: CandidateView(engine))
my_collection.ask('Find candidates from United States')

Troubleshooting Tips

If you encounter issues while using db-ally, here are some general troubleshooting ideas:

• Installation Problems: Make sure you have the latest version of pip. You can upgrade it by running pip install --upgrade pip.
• Query Failures: Ensure that your filters and views are correctly defined. Double-check your syntax and the names of your models.
• Connection Issues: Verify your database connection string; improper paths can ruin your attempts to fetch data.

For more insights, updates, or to collaborate on AI development projects, stay connected with fxis.ai.

Explore More

If you would like to dive deeper, explore the Quickstart Guide or check the Tutorials.

At fxis.ai, we believe that such advancements are crucial for the future of AI, as they enable more comprehensive and effective solutions. Our team is continually exploring new methodologies to push the envelope in artificial intelligence, ensuring that our clients benefit from the latest technological innovations.