In the field of application development, especially in data science and AI applications, choosing the right tools to create, deploy, and manage applications is crucial. This article will delve into a new approach for rapidly building and deploying AI web applications using Streamlit + FastAPI, clarifying its architecture, working mechanism, advantages, and practical use cases, along with providing practical example programs.
1. Overview
Streamlit
Streamlit is an open-source Python library designed to help developers easily create web applications for data projects with minimal effort. It emphasizes simplicity, allowing developers to transform data scripts into shareable web applications using concise and understandable code.
FastAPI
FastAPI is a modern, fast (high-performance) web framework for building APIs with Python 3.7+. It aims to create robust and efficient APIs, making it particularly suitable for building data applications due to its fast execution and efficient data processing capabilities.
2. Streamlit + FastAPI
Streamlit as Frontend
•Develop User Interface: Use Streamlit to develop the user interface of the application, providing users with an interactive and visually appealing way to interact with data.•Data Visualization: It allows developers to create various visual data representations, such as charts and graphs, to present data in an easily understandable format.•User Interaction: Through various components of Streamlit, Streamlit applications can receive user input and display visual results.
FastAPI as Backend
•Handle Business Logic: FastAPI manages the business logic of the application, processes data, executes algorithms, and ensures that the application runs as expected.•Interact with Database: It handles interactions with the database, ensuring data is correctly stored, retrieved, updated, and deleted according to the application’s requirements.•Manage Data Processing Tasks: FastAPI can manage various data processing tasks, ensuring data is correctly processed and manipulated before being sent to the frontend.
Overall Interaction Process
1.User Interaction: Users interact with the Streamlit application, using widgets to input data and request specific visualizations or analyses.2.Data Visualization: Streamlit can provide visual outputs based on user inputs and potentially pre-processed data.3.Request Handling: When more complex data processing or retrieval is needed, Streamlit communicates with the FastAPI backend, sending requests to specific APIs.4.Data Processing: FastAPI processes the data as needed, interacts with the database, and executes business logic.5.Response: FastAPI returns the processed data to the Streamlit frontend.6.Display Results: Streamlit updates the displayed data and visual outputs based on the processed data received from FastAPI.
This architecture allows developers to leverage the simplicity and interactivity of Streamlit for user interfaces and data visualization while utilizing the robustness and efficiency of FastAPI for backend processing, data management, and business logic.
3. Why Use the Streamlit + FastAPI Architecture
1. Rapid MVP Development
•Simplified Development: Streamlit allows developers to quickly convert data scripts into web applications without needing deep knowledge of frontend technologies.•Fast Iteration: Developers can immediately see the effects of code changes on the application, enabling rapid iterations.
2. Scalability
•Asynchronous Capabilities: FastAPI supports asynchronous request handling, allowing it to manage multiple requests concurrently, which is crucial for high-traffic applications.•Performance: FastAPI is known for its high performance, ensuring that applications can scale to handle increased loads without significantly degrading response times.•Easy Migration: If the MVP version performs well, Streamlit can be quickly switched to a professional frontend application, while the backend FastAPI requires almost no modifications.
3. Easy to Get Started
•Python-Based: Both Streamlit and FastAPI are developed in Python, making it easy for developers familiar with Python to use them, ensuring a smooth learning curve.•Simplified Syntax: The syntax of both frameworks is designed to be simple and intuitive, allowing developers to focus on building functionality rather than getting bogged down in complex syntax.
4. Good Community and Ecosystem
•Active Community: Both Streamlit and FastAPI have active supportive communities that provide rich knowledge, resources, and help through forums, social media, and other platforms.•Good Ecosystem: The ecosystems of these two tools include various plugins, extensions, and integrations, making it easy for developers to extend functionality and integrate with other tools and technologies.
4. Practical Case: Stock Price Visualization Application
FastAPI + Streamlit is a new approach to creating AI applications that fully leverages the strengths of both frameworks. Below is a comprehensive code example demonstrating how to integrate FastAPI with Streamlit to rapidly build and deploy applications.
FastAPI Code
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()
class StockRequest(BaseModel): symbol: str
@app.post("/get_stock")
async def get_stock(data: StockRequest): # Here you might fetch real stock data, for simplicity returning a static response return {"symbol": data.symbol, "price": 100.0}Streamlit Code
import streamlit as st
import requests
st.title('Stock Price App')
symbol = st.text_input("Enter Stock Symbol:", value="AAPL")
if st.button('Get Price'): response = requests.post("http://localhost:8000/get_stock", json={"symbol": symbol}) if response.status_code == 200: stock_data = response.json() st.write(f"The price of {stock_data['symbol']} is ${stock_data['price']}") else: st.write("Error fetching the stock price")With just a few lines of simple code, you can achieve the following effect:
For more detailed code and building steps, please check my GitHub repository[1].
5. Conclusion
The integration of Streamlit and FastAPI provides a new approach for developing data/AI-driven web applications, combining the simplicity of Streamlit with the high performance and scalability of FastAPI, which not only facilitates rapid development but also ensures the scalability and maintainability of applications, allowing for seamless deployment using modern technologies and platforms.
References
[1] My GitHub repository: https://github.com/hunterzhang86/Streamlit-FastAPI