How often do you find yourself buried under a mountain of documents, ranging from technical documentation, reports, and whitepapers to academic research and even YouTube videos? Have you ever thought of securely delegating the work of parsing and analyzing information to a Large Language Model (LLM) assistant?

While there’s an abundance of material on the implementation of LLM-based conversational tools, most lack practical guidance on deploying an LLM assistant within a web application context. Fortunately, with the help of modern innovative libraries, creating and deploying a personalized knowledge retrieval tool — both securely and efficiently — has become more attainable than ever.

Using natural language to interact with knowledge bases, PDFs, YouTube videos, and heaps of online information is a very effective use case for LLM-based applications. It’s no surprise that there’s no dearth of tools and services that enable such interaction. Notable mentions in this realm include ChatDOC, ChatDocuments, and LightPDF.

Most of these tools leverage a popular LLM technique called Retrieval Augmented Generation (RAG), colloquially known as “rag”. Its primary function is to segment source documents into text chunks and then retrieve those that align most closely with a user’s query.

Understanding RAG

Retrieval Augmented Generation, or RAG, has garnered substantial attention recently. Since extensive literature is available about this topic, let’s take a brief overview.

In essence, RAG operates by segmenting source documents into manageable chunks. These chunks are then vectorized and stored in vector databases. When a user poses a query, the system fetches the relevant chunks, which are then processed by LLMs such as GPT-4 to craft a comprehensive response (Figure 1).

For those interested in reading more, I recommend the following resources:

• Add Your Own Data to an LLM Using Retrieval-Augmented Generation (RAG)
• What is retrieval-augmented generation?
• Retrieval Augmented Generation (RAG): Reducing Hallucinations in GenAI Applications.

Building a RAG workflow

Constructing a Retrieval Augmented Generation (RAG) workflow involves a sequence of interconnected components: a data loader, a chunking algorithm, an embedding model, a vector database, retrieval algorithms, and of course, an LLM. Designing a RAG workflow from scratch could be a tall order, requiring one to choose tools for each of these components and meticulously select their configurations.

Enter Embedchain, an open-source Python library that streamlines the entire process of building a RAG pipeline on many different source data formats. Embedchain builds upon Langchain but smartly trims down configuration choices by defining and selecting optimal defaults. This makes it a convenient choice for our web application.

Let’s walk through how to deploy a rudimentary RAG workflow using Embedchain:

import os
from embedchain import App

os.environ["OPENAI_API_KEY"] = "sk_xxxx"

def explore_your_knowledge_base(web_page_urls: list, 
                                query: str) -> str:
    "Interact with your web resources"

    # Define a custom app
    app = App()

    # Iteratively add all URLs to the app's vectorstore
    [app.add(url) for url in web_page_urls]

    # Query the LLM (gpt-3.5-turbo by default)
    response = app.query(query)

    return response

Just like that, you’re set! By default, Embedchain opts for OpenAI’s gpt-3.5-turbo LLM, the text-embedding-ada-002 model for embeddings, and ChromaDB for the vector database. Read about all the other configurations on Embedchain’s documentation page.

To make our application conversational, we can adjust the configurations slightly by choosing a custom prompt and tracking the conversation history. We should also handle preliminary validations, like checking for API keys and queries. The complete modified code for the Embedchain app is hosted on GitHub.

Deploying RAG as a web application

We saw how easy it is to build an LLM-based RAG workflow using Embedchain. Our next goal is its web deployment. This is where Fast Dash — another versatile Python library — comes into play.

Disclaimer: As the author of Fast Dash, I designed this tool aiming to swiftly create and launch Python-based prototypes. It provided me an avenue to share intricate analytics and machine learning outcomes seamlessly with my colleagues.

At its core, Fast Dash operates on two guiding principles.

1. Simplicity in Function: Every web application can be distilled down to a single Python function.
2. Function Annotations: With thorough annotations, a Python function can carry all the blueprint details needed for an interactive web application.

Fast Dash inculcates these principles by incorporating a @fastdash decorator for our Python functions. To learn more, refer to the Fast Dash documentation or read this post.

To transform our Embedchain RAG workflow into a web application, here’s the adjusted code:

import os
from embedchain import App
from fast_dash import fastdash, Chat, dmc

os.environ["OPENAI_API_KEY"] = "sk-xxxx"

web_page_urls_component = dmc.MultiSelect(
    description="Include all the reference web URLs",
    placeholder="Enter URLs separated by commas",
    searchable=True,
    creatable=True
)

@fastdash
def explore_your_knowledge_base(web_page_urls: web_page_urls_component, 
                                query:str) -> Chat:
    "Interact with your web resources"

    # Define a custom app
    app = App()

    # Iteratively add all URLs to the app's vectorstore
    [app.add(url) for url in web_page_urls]

    # Query the LLM (gpt-3.5-turbo by default)
    response = app.query(query)

    # Convert this conversation into a dictionary 
    # to render a chat interface
    chat = dict(query=query, response=response)

    return chat

Running this code will deploy the Python function as a fully functioning web app! Notice the minor modifications we made to our original function:

1. Modified Annotations: We modified input and output data type annotations. Fast Dash reads and understands these annotations. In this case, Fast Dash uses the Dash component web_page_urls_component to display a list of URLs and a text input box for the query. Besides that, we also use the Fast Dash component Chat to render a chat interface as the output.
2. Refined Return Type: Instead of returning a response string, we modify the function to return a dictionary with two keys, query and response, as required by the Chat component.
3. @fastdash Decorator: Finally, we add a @fastdash decorator to deploy our function as a fully functioning web application.

Running the above script will deploy this application to port 8080 by default. Here’s how it looks:

We can also incorporate additional input parameters or even offload the OpenAI API key responsibility to the user. On doing that, here’s what we get.

The full source code to build and deploy this web application is hosted publicly at https://github.com/dkedar7/embedchain-fastdash.

GitHub - dkedar7/embedchain-fastdash: Built with Fast Dash, this app uses Embedchain, which abstracts the entire process of loading and chunking datasets, creating embeddings, and storing them in a vector database. Embedchain itself uses Langchain and OpenAI's ChatGPT API.

Deploying to a cloud service

One of the many benefits of Fast Dash being Flask-based is the ease of deploying apps using Gunicorn in production environments. Our next step is to encapsulate the app within a Docker container and host it using Google Cloud’s Cloud Run service.

Google Cloud Run allows deploying a web app directly from its publicly hosted GitHub repository. To see this in action, navigate to the app repository here and click on the “Deploy on Google Cloud” button. This ensures a safe and streamlined deployment of the app onto your Google Cloud setup.

While the entire deployment process typically takes between 10 to 15 minutes, here’s a time-lapsed video to showcase the deployment steps.

Conclusion

The task of constructing a knowledge retrieval application can initially seem overwhelming. However, as we saw, the rise of innovative libraries and tools has remarkably simplified the process. These innovations not only streamline the development but also deployment, making the once-arduous task nearly turnkey.

For one-click deployment of your own knowledge retrieval web application, visit the GitHub repository and use the “Deploy on Google Cloud” button!

Fast Dash makes prototyping and deploying machine learning web applications lightning fast!

If you are a machine learning practitioner or hobbyist, I bet you enjoy exploring the latest and greatest tools and sharing them with colleagues, friends, and your network.

Enter Fast Dash: a revolutionary Python library crafted with you in mind. It seamlessly transforms your Python functions into deployable web applications, allowing you to focus on the nuances of machine learning and worry about the nitty-gritty of web development.

Let’s be honest: a lot of app development time is spent figuring out user interfaces and how different components talk to each other. After countless hours building web apps, it struck me: why not automate a big chunk of this? That inspiration led to Fast Dash, designed to get your web apps up and running in record time.

Here’s a simple example: creating a web app that displays Matplotlib charts to give you a taste of what Fast Dash can do.

Fast Dash is pretty intuitive. It reads everything about your Python function, examining elements like its name, input and output argument labels, data types, and docstrings. With all this information, it designs an interactive user interface on the fly and then deploys it as a full-blown web application!

Read on for details about how Fast Dash works, how to get started, and how to customize your apps. If you’d instead give it a whirl first, just pip install fast-dash . Check out the GitHub repo and the documentation to learn more.

• pip install fast-dash
• GitHub: github.com/dkedar7/fast_dash

How does Fast Dash work?

Fast Dash is based on two foundational principles.

1. Every web application can be distilled down to a single Python function.
2. With thorough annotations, a Python function can carry all the blueprint details needed for an interactive web application.

Your Python function and Fast Dash app configurations together determine how the app is deployed and the level of user interaction. Nail down a well-documented function, and you’ll find there’s barely any need to tinker with app settings.

The ability to read and understand Python functions enables Fast Dash to choose the best components and interactivity for your app. As of now, Fast Dash supports a Plotly Dash backend only. This means that Fast Dash can be deployed like any other Flask app.

Building your Fast Dash apps

Just slapping @fastdash before your Python function is the easiest way to build a Fast Dash app. With the@fastdash decorator, Fast Dash deploys your function eagerly. Let’s break it down with a basic example:

from fast_dash import fastdash

@fastdash
def text_to_text_function(input_text):
    return input_text
# * Running on http://127.0.0.1:8080/ (Press CTRL+C to quit)

The outcome? Check it out:

But Fast Dash’s charm doesn’t stop at simple tasks. Armed with the right input and output type hints, it’s capable of deploying even the most intricate Python functions.

Consider this example:

import PIL
import matplotlib.pyplot as plt
from fast_dash import fastdash, Graph

output_layout = """
AB
AC
"""
@fastdash(mosaic=output_layout, theme="BOOTSTRAP")
def multiple_output_components(start_date: datetime.date, # Adds a date component
                            upload_image: PIL.ImageFile, # Adds an upload component
                            fips: str = ["01007", "01008", "01009"]) # Adds a single-select dropdown
                            -> (Graph, plt.Figure, plt.Figure): 
                            # Output components are a Plotly graph, and two figure components
    "Fast Dash allows using mosaic arrays to arrange output components"
    choropleth_map = ... # Plotly Graph code
    histogram = ... # Matplotlib figure code
    radar_chart = ... # Matplotlib figure code
    return chloropleth_map, histogram, radar_chart
# * Running on http://127.0.0.1:8080/ (Press CTRL+C to quit)

And voila! Here’s our function in action:

One of the standout features of Fast Dash is its flexibility. While it offers a swift default mechanism to convert data type hints into components, it doesn’t restrict you. You can also employ Dash components directly as type hints, tailoring the components to fit your exact needs.

For example, instead of upload_image: PIL.ImageFile, you can also write upload_image: dcc.Upload(...) . This way, you can customize the component to your liking, bypassing Fast Dash’s default selection for the PIL.ImageFile data type.

Fast Dash can be used to build web apps wherever you use Python. Its versatility is evident across multiple domains. Here are some examples where Fast Dash powered projects in generative AI, language translation, computer vision, and geospatial analytics (NASA models and Geemap) web applications.

Customizing your Fast Dash apps

Besides allowing rapid deployment, you can tweak and twist various aspects of your web apps to suit your purpose. You can switch the theme, adjust the title and subheader, add social media links, or deploy within Jupyter Notebook instead of a separate port. Read more about customizing here.

For now, let’s focus on customizing the visual arrangement of output components. The concept is all about “mosaics.” Drawing inspiration from Matplotlib’s subplot_mosaic method, Fast Dash lets you craft layouts using an ASCII-esque diagram or a string list.

Each unique letter or string in this mosaic signifies a unique component. This approach is a game-changer, especially when you’re aiming for non-uniform grid layouts.

For example, imagine the output arrangement you want is something like in the following image:

In which case, you can define your mosaic to be “ABB \n CDE”. Fast Dash would then prep for five outputs. Fast Dash divides the space into six equally-sized boxes placed in a 2 x 3 grid. The first output gets the top-left box. The second output stretches across the next two boxes in the top row. And each of the remaining three outputs gets its own box in the row below.

In Conclusion

At its core, Fast Dash is all about simplification. It abstracts away much of the frontend and server management work, allowing developers to focus on what they do best: writing effective, efficient Python code.

It’s not just a tool for rapid prototyping. With its customization options and inherent documentation capabilities, Fast Dash can be a staple in any developer’s toolkit, from the seasoned web dev professional to the budding data scientist.

With Fast Dash, the future of Python-based web app development looks not only brighter but also faster. And in today’s tech landscape, that’s a combination hard to beat.

So, star the repo and pip install fast-dash today!

WRITER at MLearning.ai / Premier AI Video / AI art Copyright

Mlearning.ai Submission Suggestions