DEV Community: Dheeraj Malhotra

A Comprehensive Comparison of the Three Major Python Web Frameworks: Which One Do You Favor? | Opinion

Dheeraj Malhotra — Tue, 20 May 2025 10:38:27 +0000

When you search for Python web frameworks, Django, Flask, and FastAPI consistently appear. Our latest Python developer survey results confirm that these three frameworks remain the top choices for developers using Python for backend web development. All three are open-source and compatible with the latest Python versions.
But how do you determine which web framework is best for your project? This article will explore the strengths and weaknesses of each framework and compare their performance.

Django

Django is a "batteries-included" full-stack web framework used by companies like Instagram, Spotify, and Dropbox. Hailed as "the web framework for perfectionists with deadlines," Django was designed to make building robust web applications simpler and faster.
First launched as an open-source project in 2005, Django is quite mature nearly 20 years later, yet it's still under active development. It's suitable for many web applications, including social media, e-commerce, and news and entertainment websites.
Django follows a Model-View-Template (MVT) architecture, where each component has a specific role. The Model handles data and defines its structure. The View manages business logic, processes requests, and fetches necessary data from the Model. Finally, the Template renders this data to the end-user, similar to the View in a Model-View-Controller (MVC) architecture.
As a full-stack web framework, Django can be used to build an entire web application, from the database to the HTML and JavaScript frontend.
Alternatively, you can combine Django with a frontend framework (like React) using Django REST Framework to build mobile and browser-based applications.
Explore our comprehensive Django guide, which includes an overview of the basics, a structured learning path, and other resources to help you master the framework.

Advantages of Django

There are many reasons why Django remains one of the most widely used Python web frameworks, including:

Extensive Functionality: Django's "batteries-included" approach provides built-in features such as authentication, caching, data validation, and session management. Its Don't Repeat Yourself (DRY) principle speeds up development and reduces bugs.
Easy Setup: Django simplifies dependency management by leveraging its built-in features, reducing the need for external packages. This streamlines initial setup, minimizes compatibility issues, and helps you get to work quickly.
Database Support: Django's ORM (Object-Relational Mapping) makes data handling straightforward, allowing you to use databases like SQLite, MySQL, and PostgreSQL without SQL knowledge. However, it's less suited for non-relational databases like MongoDB.
Security: Built-in defenses against common vulnerabilities like Cross-Site Scripting (XSS), SQL injection, and clickjacking can help you secure your application quickly from the start.
Scalability: While monolithic, Django still allows for horizontal scaling of application architecture (business logic and templates), caching to reduce database load, and asynchronous processing for improved efficiency.
Community and Documentation: Django boasts a large, active community and detailed documentation, providing ready-made tutorials and support. ### Disadvantages of Django Despite its many advantages, you might consider options other than Django when developing your next web application.
Not Lightweight: Its "batteries-included" design can be overkill for small applications, where a lightweight framework like Flask might be more suitable.
Steeper Learning Curve: With Django's extensive functionality comes a naturally steeper learning curve, though many resources are available to help new developers.
Performance: Django is generally slower compared to frameworks like Flask and FastAPI, but built-in caching and asynchronous processing can help improve response times.

Flask

Flask is a Python-based microframework for backend web development. But don't let the "micro" fool you; as we'll see, Flask isn't limited to small web applications.

Flask is designed with a simple core based on Werkzeug WSGI (Web Server Gateway Interface) and Jinja2 templates. Notable Flask users include Netflix, Airbnb, and Reddit.
Originally an April Fool's joke, Flask was released as an open-source project in 2010, a few years after Django. The microframework approach is fundamentally different from Django's. While Django takes a "batteries-included" approach with many features needed to build web applications, Flask is much more minimalist.
The philosophy behind microframeworks is that everyone has their preferences, and developers should be free to choose their components. As a result, Flask doesn't include a database, ORM (Object-Relational Mapper), or ODM (Object Document Mapper).
When building a web application with Flask, very little is predetermined. This can offer significant benefits, which we'll discuss below.

Advantages of Flask

Through our State of the Developer Ecosystem survey, we've seen Flask's usage steadily increase over the past five years, surpassing Django for the first time in 2021.
Reasons to choose Flask as your backend web framework include:

Lightweight Design: Flask's minimalist approach offers a flexible alternative to Django, ideal for smaller applications or projects that don't need Django's extensive features. However, Flask isn't limited to small projects and can be scaled as needed.
Flexibility: Flask allows you to choose libraries and frameworks for core functionalities like data handling and user authentication. This enables you to select the best tools for your project and scale in unprecedented ways.
Scalability: Flask's modular design makes it easy to scale horizontally. Using a NoSQL database layer can further enhance scalability.
Gentle Learning Curve: Flask's simple design makes it easy to learn, though for more complex applications, you might need to explore more extensions.
Community and Documentation: Flask has extensive (perhaps slightly more technical) documentation and a clear codebase. While Flask's community is smaller than Django's, it's consistently active and steadily growing.

Disadvantages of Flask

While Flask has many advantages, you should consider a few things before using it for your web development project.

Bring Your Own Everything: Flask's microframework design and flexibility require you to handle most core functionalities, including data validation, session management, and caching. While beneficial for flexibility, this can slow down development as you need to find existing libraries or build features from scratch. Additionally, long-term dependency management is necessary to ensure compatibility with Flask.
Security: Flask has minimal built-in security. Beyond protecting client cookies, you must implement web security best practices and ensure the security of included dependencies, applying updates as needed.
Performance: While Flask performs slightly better than Django, it lags behind FastAPI. Flask offers some ASGI support (the standard used by FastAPI), but it's more closely tied to WSGI.

FastAPI

As the name suggests, FastAPI is a microframework for building high-performance web APIs using Python. Although relatively new (first released as open source in 2018), FastAPI has quickly gained popularity among developers, consistently ranking third in our list of most popular Python web frameworks since 2021.
FastAPI is built on the ASGI (Asynchronous Server Gateway Interface) server Uvicorn and the web microframework Starlette. FastAPI adds data validation, serialization, and documentation to simplify building web APIs.

When developing FastAPI, the creators of this microframework drew on their experience using many different frameworks and tools. Django was developed before frontend JavaScript web frameworks (like React or Vue.js) became popular, but FastAPI was designed with this environment in mind.
In previous years, OpenAPI (formerly Swagger) emerged as a format for defining API structures and documenting APIs, providing FastAPI with an industry standard it could leverage.
Beyond the implicit use case of creating RESTful APIs, FastAPI is also ideal for applications requiring real-time responses, such as messaging platforms and dashboards. Its high performance and asynchronous capabilities make it excellent for data-intensive applications, including machine learning models, data processing, and analysis.

Advantages of FastAPI

In 2021, FastAPI first earned its own category in our State of the Developer Ecosystem survey, with 14% of respondents using this microframework.
Since then, its usage has increased to 20%, while Flask and Django have seen slight declines in usage.
Here are some reasons why developers choose FastAPI:

Performance: FastAPI is designed for speed, supporting asynchronous processing and bidirectional WebSockets (provided by Starlette). It outperforms Django and Flask in benchmarks, making it ideal for high-traffic applications.
Scalability: Like Flask, FastAPI is highly modular, making it easy to scale and perfectly suited for containerized deployments.
Adherence to Industry Standards: FastAPI is fully compatible with OAuth 2.0, OpenAPI (formerly Swagger), and JSON Schema. This allows for easy implementation of secure authentication and generation of API documentation.
Ease of Use: FastAPI uses Pydantic for type hints and validation, accelerating development by providing type checking, autocompletion, and request validation.
Documentation: FastAPI comes with extensive documentation, and third-party resources are continuously growing, making it accessible to developers of all levels.

Disadvantages of FastAPI

Before deciding to use FastAPI for your project, consider the following:

Maturity: FastAPI is newer and lacks the maturity of Django or Flask. Its community is smaller, and the user experience might be less smooth due to less widespread use.
Compatibility: As a microframework, FastAPI requires additional functionality to become a fully functional application. There are fewer compatible libraries compared to Django or Flask, which might require you to develop your own extensions.

Choosing Between Flask, Django, and FastAPI

So, which Python web framework is best? As with many programming endeavors, the answer is "it depends."
The right choice depends on the answers to several questions: What type of application are you building? What are your priorities? How do you expect the project to evolve in the future?

All three popular Python web frameworks have unique strengths, so evaluating them based on your application will help you make the best decision.

If you need standard web application features out of the box, Django is a good choice, suitable for projects requiring a more robust structure. Its advantages are particularly evident when using relational databases, as its ORM simplifies data management and provides built-in security features. However, for smaller projects or simple applications, such extensive features might be overkill.
Flask offers greater flexibility. Its minimalist design allows developers to pick and choose their desired extensions and libraries, making it suitable for projects needing custom functionality. This approach is ideal for startups or MVPs where requirements might change and evolve quickly. While Flask is easy to get started with, remember that building more complex applications will involve exploring many extensions.

If speed is the top priority, FastAPI is a strong contender, especially for API-first or machine learning projects. It leverages modern Python features like type hints to provide automatic data validation and documentation. For applications requiring high performance, such as microservices or data-driven APIs, FastAPI is an excellent choice. Nevertheless, it might not be as rich in built-in features as Django or Flask, and you might need to manually implement additional functionalities.

Comprehensive Comparison of the Three Python Web Frameworks

Kickstart Your Web Development Project with ServBay

No matter which framework you choose, you'll need to set up a Python environment before web development. ServBay is currently the most convenient tool for this. ServBay provides support for Python 2.7, 3.5-3.14, making it suitable for both new and old projects.
Do you have a specific project in mind that would help you decide which framework to use?

Build Your Own AI Chatbot: A Complete Guide to Local Deployment with ServBay, Python, and ChromaDB

Dheeraj Malhotra — Fri, 14 Mar 2025 14:53:28 +0000

In an era where data privacy is paramount, setting up your own local language model (LLM) provides a crucial solution for companies and individuals alike. This tutorial is designed to guide you through the process of creating a custom chatbot using ServBay, Python 3, and ChromaDB, all hosted locally on your system. Exactly, you don't need to download any software except for Servbay. Here are the key reasons why you need this tutorial:

Complete Customization: Full control over configuration allows you to tailor the model to your specific needs without relying on third-party services.
Improved Privacy: Deploying your language model (LLM) locally protects sensitive information from online transmission risks, crucial for organizations handling private data.
Data Security Assurance: Minimizes security threats by keeping training materials, such as PDF files, secure within your environment, reducing exposure to external risks.
Control Over Data Management: Freedom to handle and process data as desired, including embedding proprietary information into a ChromaDB vector store, ensuring alignment with your standards.
Internet Independence: Ensures consistent access to your chatbot without needing an internet connection, maintaining service even when offline.

This tutorial aims to guide you in building a robust and secure local chatbot that prioritizes your privacy and control.

Retrieval-Augmented Generation (RAG)

Retrieval-Augmented Generation (RAG) is an advanced technique that combines the strengths of information retrieval and text generation to create more accurate and contextually relevant responses. Here's a breakdown of how RAG works and why it's beneficial:

What is RAG?

RAG is a hybrid model that enhances the capabilities of language models by incorporating an external knowledge base or document store. The process involves two main components:

Retrieval: In this phase, the model retrieves relevant documents or pieces of information from an external source, such as a database or a vector store, based on the input query.
Generation: The retrieved information is then used by a generative language model to produce a coherent and contextually appropriate response.

How Does RAG Work?

Query Input: The user inputs a query or question.
Document Retrieval: The system uses the query to search an external knowledge base, retrieving the most relevant documents or snippets of information.
Response Generation: The generative model processes the retrieved information, integrating it with its own knowledge to generate a detailed and accurate response.
Output: The final response, enriched with specific and relevant details from the knowledge base, is presented to the user.

Benefits of RAG

Enhanced Accuracy: By leveraging external data, RAG models can provide more precise and detailed answers, especially for domain-specific queries.
Contextual Relevance: The retrieval component ensures that the generated response is grounded in relevant and up-to-date information, improving the overall quality of the response.
Scalability: RAG systems can be easily scaled to incorporate vast amounts of data, enabling them to handle a wide range of queries and topics.
Flexibility: These models can be adapted to various domains by simply updating or expanding the external knowledge base, making them highly versatile.

Why Use RAG Locally?

Privacy and Security: Running a RAG model locally ensures that sensitive data remains secure and private, as it does not need to be sent to external servers.
Customization: You can tailor the retrieval and generation processes to suit your specific needs, including integrating proprietary data sources.
Independence: A local setup ensures that your system remains operational even without internet connectivity, providing consistent and reliable service. By setting up a local RAG application with tools like Ollama, Python, and ChromaDB, you can enjoy the benefits of advanced language models while maintaining control over your data and customization options.

ServBay

ServBay is an integrated, graphical, one-click installation local web development environment designed specifically for web developers, Python developers, AI developers, and PHP developers. This software is particularly well-suited for macOS. It includes a range of commonly used web development services and tools, covering web servers, databases, programming languages, mail servers, queue services, and more. ServBay aims to provide developers with a convenient, efficient, and unified development environment.

Core Features of ServBay

Support for Multiple Python Versions: Run multiple Python versions simultaneously to meet the needs of different projects.
Custom Domain Names and SSL Support: Easily configure local domain names and SSL certificates to simulate real production environments.
Quick Operations: Supports startup on boot, quick access via the menu bar, and command-line management to enhance development efficiency.
Unified Service Management: Integrates Python, PHP, Node.js, and Ollama, making it easy to manage multiple development services.
Clean System Environment: Avoids system pollution by running all services in isolated environments.
Intranet Penetration and Sharing: Supports intranet penetration for local websites, making it easier to share development results with team members.

ServBay Installation Guide

Requirements: macOS 12.0 Monterey or later
Download the Latest Version of ServBay

Installation:

Double-click the downloaded .dmg file to open it.
In the opened window, drag the ServBay.app icon into the Applications folder.

When using ServBay for the first time, initialization is required. Generally, you can select the default installation, or optionally select Ollama for AI programming support.

After installation is complete, open ServBay.
Enter your password. After the installation is complete, you can find ServBay in the Applications directory.
Access the main interface.

In addition to Python, ServBay also provides robust support for PHP and Node.js, covering a wide range of versions from PHP 5.6 to PHP 8.5 and Node.js 12 to Node.js 23.
One of ServBay's key features is the ability to quickly switch between different software versions. This flexibility is essential for developers who need to test and deploy applications in various environments.

One-click installation of all Python versions

One-click installation of all Ollama models

Prerequisites

Before diving into the setup, ensure you have the following prerequisites in place:

Python 3: Python is a versatile programming language that you'll use to write the code for your RAG app.
ChromaDB: A vector database that will store and manage the embeddings of our data.
Servbay: To download and serve custom LLMs in our local machine.

Step 1: Install Python 3 and setup your environment

To install and setup our Python 3 environment, follow these steps:
Click the python button of servbay, and then select one version of python.
Then make sure your Python 3 installed and run successfully:

$ python3 --version# Python 3.12.9

Create a folder for your project. For example, local-rag:

$ mkdir local-rag
$ cd local-rag

Create a virtual environment named venv:

$ python3 -m venv venv

Activate the virtual environment:

$ source venv/bin/activate
# Windows# venv\Scripts\activate

Step 2: Install ChromaDB and other dependencies

Install ChromaDB using pip:

$ pip install --q chromadb

Install Langchain tools to work seamlessly with your model:

$ pip install --q unstructured langchain langchain-text-splitters
$ pip install --q "unstructured[all-docs]"

Install Flask to serve your app as a HTTP service:

$ pip install --q flask

Step 3: Install Ollama

To install Ollama, follow these steps:
Click the AI button of servbay, and then select a model you like.

Build the RAG app

Now that you've set up your environment with Python, Ollama, ChromaDB and other dependencies, it's time to build your custom local RAG app. In this section, we'll walk through the hands-on Python code and provide an overview of how to structure your application.
app.py
This is the main Flask application file. It defines routes for embedding files to the vector database, and retrieving the response from the model.

import os  
from dotenv import load_dotenv  
from flask import Flask, request, jsonify  
from embed import embed  
from query import query  
from get_vector_db import get_vector_db  

# 设置临时文件夹  
TEMP_FOLDER = os.getenv('TEMP_FOLDER', './_temp')  
os.makedirs(TEMP_FOLDER, exist_ok=True)  

app = Flask(__name__)  

@app.route('/embed', methods=['POST'])  
def route_embed():  
    if 'file' not in request.files:  
        return jsonify({"error": "No file part"}), 400  

    file = request.files['file']  
    if file.filename == '':  
        return jsonify({"error": "No selected file"}), 400  

    embedded = embed(file)  
    if embedded:  
        return jsonify({"message": "File embedded successfully"}), 200  

    return jsonify({"error": "File embedded unsuccessfully"}), 400  

@app.route('/query', methods=['POST'])  
def route_query():  
    data = request.get_json()  
    response = query(data.get('query'))  
    if response:  
        return jsonify({"message": response}), 200  

    return jsonify({"error": "Something went wrong"}), 400  

if __name__ == '__main__':  
    app.run(host="0.0.0.0", port=8080, debug=True)

embed.py
This module handles the embedding process, including saving uploaded files, loading and splitting data, and adding documents to the vector database.

import os  
from datetime import datetime  
from werkzeug.utils import secure_filename  
from langchain_community.document_loaders import UnstructuredPDFLoader  
from langchain_text_splitters import RecursiveCharacterTextSplitter  
from get_vector_db import get_vector_db  

TEMP_FOLDER = os.getenv('TEMP_FOLDER', './_temp')  

# Function to check if the uploaded file is allowed (only PDF files)  
def allowed_file(filename):  
    return '.' in filename and filename.rsplit('.', 1)[1].lower() in {'pdf'}  

# Function to save the uploaded file to the temporary folder  
def save_file(file):  
    # Save the uploaded file with a secure filename and return the file path  
    timestamp = datetime.now().timestamp()  
    filename = f"{timestamp}_{secure_filename(file.filename)}"  
    file_path = os.path.join(TEMP_FOLDER, filename)  
    file.save(file_path)  
    return file_path  

# Function to load and split the data from the PDF file  
def load_and_split_data(file_path):  
    # Load the PDF file and split the data into chunks  
    loader = UnstructuredPDFLoader(file_path=file_path)  
    data = loader.load()  
    text_splitter = RecursiveCharacterTextSplitter(chunk_size=7500, chunk_overlap=100)  
    chunks = text_splitter.split_documents(data)  
    return chunks  

# Main function to handle the embedding process  
def embed(file):  
    # Check if the file is valid, save it, load and split the data, add to the database, and remove the temporary file  
    if file.filename != '' and file and allowed_file(file.filename):  
        file_path = save_file(file)  
        chunks = load_and_split_data(file_path)  
        db = get_vector_db()  
        db.add_documents(chunks)  
        db.persist()  
        os.remove(file_path)  
        return True  
    return False

query.py
This module processes user queries by generating multiple versions of the query, retrieving relevant documents, and providing answers based on the context.

import os  
from langchain_community.chat_models import ChatOllama  
from langchain.prompts import ChatPromptTemplate, PromptTemplate  
from langchain_core.output_parsers import StrOutputParser  
from langchain_core.runnables import RunnablePassthrough  
from langchain.retrievers.multi_query import MultiQueryRetriever  
from get_vector_db import get_vector_db  

LLM_MODEL = os.getenv('LLM_MODEL', 'deepseek-r1:1.5b')  

# Function to get the prompt templates for generating alternative questions and answering based on context  
def get_prompt():  
    QUERY_PROMPT = PromptTemplate(  
        input_variables=["question"],  
        template="""You are an AI language model assistant. Your task is to generate five  
        different versions of the given user question to retrieve relevant documents from  
        a vector database. By generating multiple perspectives on the user question, your  
        goal is to help the user overcome some of the limitations of the distance-based  
        similarity search. Provide these alternative questions separated by newlines.  
        Original question: {question}"""  
    )  

    template = """Answer the question based ONLY on the following context:  
    {context}  
    Question: {question}"""  

    prompt = ChatPromptTemplate.from_template(template)  
    return QUERY_PROMPT, prompt  

# Main function to handle the query process  
def query(input):  
    if input:  
        # Initialize the language model with the specified model name  
        llm = ChatOllama(model=LLM_MODEL)  

        # Get the vector database instance  
        db = get_vector_db()  

        # Get the prompt templates  
        QUERY_PROMPT, prompt = get_prompt()  

        # Set up the retriever to generate multiple queries using the language model and the query prompt  
        retriever = MultiQueryRetriever.from_llm(db.as_retriever(), llm, prompt=QUERY_PROMPT)  

        # Define the processing chain to retrieve context, generate the answer, and parse the output  
        chain = ({"context": retriever, "question": RunnablePassthrough()} | prompt | llm | StrOutputParser())  

        response = chain.invoke(input)  
        return response  

    return None

get_vector_db.py
This module initializes and returns the vector database instance used for storing and retrieving document embeddings.

import os  
from langchain_community.embeddings import OllamaEmbeddings  
from langchain_community.vectorstores.chroma import Chroma  

CHROMA_PATH = os.getenv('CHROMA_PATH', 'chroma')  
COLLECTION_NAME = os.getenv('COLLECTION_NAME', 'local-rag')  
TEXT_EMBEDDING_MODEL = os.getenv('TEXT_EMBEDDING_MODEL', 'nomic-embed-text')  

def get_vector_db():  
    # Create an instance of the embedding model  
    embedding = OllamaEmbeddings(model=TEXT_EMBEDDING_MODEL, show_progress=True)  

    # Initialize the Chroma vector store with specified parameters  
    db = Chroma(  
        collection_name=COLLECTION_NAME,  
        persist_directory=CHROMA_PATH,  
        embedding_function=embedding  
    )  

    return db

Run your app!

Create .env file to store your environment variables:

TEMP_FOLDER = './_temp'
CHROMA_PATH = 'chroma'
COLLECTION_NAME = 'local-rag'
LLM_MODEL = 'mistral'
TEXT_EMBEDDING_MODEL = 'nomic-embed-text'

Run the app.py file to start your app server:

python3 app.py

Once the server is running, you can start making requests to the following endpoints:

Example command to embed a PDF file (e.g., resume.pdf):

#!/bin/bash  

curl --request POST \
--url http://localhost:8080/embed \
--header 'Content-Type: multipart/form-data' \
--form file=@/Users/liyinan/Documents/works/matrix_multi.pdf

Response
{
"message": "File embedded successfully"
}

Example command to ask a question to your model:


$ curl --request POST \
  --url http://localhost:8080/query \
  --header 'Content-Type: application/json' \
  --data '{ "query": "Who is Nasser?" }'

# Response
{
  "message": "Nasser Maronie is a Full Stack Developer with experience in web and mobile app development. He has worked as a Lead Full Stack Engineer at Ulventech, a Senior Full Stack Engineer at Speedoc, a Senior Frontend Engineer at Irvins, and a Software Engineer at Tokopedia. His tech stacks include Typescript, ReactJS, VueJS, React Native, NodeJS, PHP, Golang, Python, MySQL, PostgresQL, MongoDB, Redis, AWS, Firebase, and Supabase. He has a Bachelor's degree in Information System from Universitas Amikom Yogyakarta."
}

Conclusion

By following these instructions, you can effectively run and interact with your custom local RAG app using Python, Ollama, and ChromaDB, tailored to your needs. Adjust and expand the functionality as necessary to enhance the capabilities of your application.
By harnessing the capabilities of local deployment, you not only safeguard sensitive information but also optimize performance and responsiveness. Whether you're enhancing customer interactions or streamlining internal processes, a locally deployed RAG application offers flexibility and robustness to adapt and grow with your requirements.

Unlocking Local AI Magic: DeepSeek and CodeGPT Empower Developers to Evolve Efficiently

Dheeraj Malhotra — Thu, 06 Mar 2025 12:24:23 +0000

With the rapid development of artificial intelligence technology, more and more developers are looking to integrate AI into their workflows. However, many cloud-based AI services may pose issues such as privacy and data security risks, high usage costs, reliance on internet connectivity, and limited customization options.Therefore, installing and running DeepSeek locally allows developers to harness the powerful capabilities of AI to enhance development efficiency while safeguarding privacy.

CodeGPT is an AI tool based on GPT technology, specifically designed for software developers. It can assist with tasks such as code generation, optimization, debugging, documentation creation, and provide precise suggestions based on context. By integrating CodeGPT with DeepSeek, you can achieve efficient AI-assisted development in a local environment without depending on external cloud services.

Below is a step-by-step guide to help you install and run DeepSeek locally and configure CodeGPT to enhance your development workflow:

Step 1: Install Ollama and CodeGPT in VSCode

To run DeepSeek locally, we first need to install Ollama, which allows us to run large language models (LLMs) on our machine, and CodeGPT, a VSCode extension that integrates these models to provide coding assistance. Using Ollama directly can be inconvenient due to issues such as having to use the command line to download models, unstable download speeds, and so on. Therefore, I decided to use a new integration tool called ServBay.

Introduction to ServBay

Ollama is a lightweight platform that makes running local LLMs simple. ServBay, on the other hand, is a more user-friendly integration tool for Ollama. It provides an intuitive graphical interface and one-click installation. ServBay is a comprehensive and graphical local web development environment designed for web developers, Python developers, AI developers, and PHP developers, particularly suitable for macOS.It incorporates a suite of commonly used web development tools and software, including web servers, databases, development languages, mail servers, queue services, and more, aiming to provide developers with a convenient, efficient, and unified development environment. Below is the list of tools and software packages currently supported by ServBay.

Download ServBay

Visit the official website: ServBay

Download the installer for macOS. Currently, only macOS is supported.
During installation, you can automatically select the option to install Ollama.

Once you enter the interface, you can directly install DeepSeek.

Install CodeGPT in Visual Studio Code

Open VSCode and navigate to the Extensions Marketplace (on macOS, press Ctrl + Shift + X or Cmd + Shift + X).
Search for “CodeGPT” and click Install.

Alternatively, you can create a free account at: https://codegpt.co.

After installing Ollama and CodeGPT, you're now ready to download and configure DeepSeek to start coding with AI locally. 🚀

Step 2: Preparing the Models

Now that you have successfully installed ServBay and CodeGPT, it's time to download the models you'll use locally.

Chat Model: deepseek-r1: 1.5b, optimized for smaller environments, capable of running smoothly on most computers.
Autocompletion Model: deepseek-coder: 1.3b, which utilizes Fill-In-The-Middle (FIM) technology. This allows it to make intelligent autocompletion suggestions as you write code, predicting and suggesting the intermediate portions of a function or method—not just the beginning or end.

Download the Chat Model (deepseek-r1: 1.5b)

Follow the steps in the interface and simply click to download.

To Start Using the Chat Model:

Open CodeGPT in VSCode.
Navigate to the Local LLMs section in the sidebar.

From the available options, select Ollama as the local LLM provider.
Select the model deepseek-r1: 1.5b. Now, you can effortlessly query the model about your code. Simply highlight any code in the editor, add extra files to the query using the # symbol, and leverage powerful command shortcuts, such as:

/fix — Used to fix errors in the code or suggest improvements.
/refactor — Used to clean up and improve the structure of the code.
/Explain — Get a detailed explanation of any code snippet. This chat model is perfect for assisting with specific problems or receiving suggestions about your code.

Download the Autocompletion Model (deepseek-coder: latest)

From the list of available models, select deepseek-coder: latest.

Once selected, you can start coding. As you type, the model will begin providing real-time code suggestions, helping you effortlessly complete functions, methods, or even entire code blocks.

Step 3: Enjoy Seamless, Local, and Private AI-Driven Coding

After setting up the models, you can now fully enjoy the benefits of these powerful tools without relying on external APIs. By running everything locally on your computer, you ensure complete privacy and control over your coding environment. Rest assured, with no data leaving your computer, everything remains secure and private.👏

If you enjoyed this article 👏 👏 👏, please give it a clap.

Make AI Models Your Perfect Roommate!

Dheeraj Malhotra — Tue, 04 Mar 2025 06:55:52 +0000

Make AI Models Your Perfect Roommate! (ServBay+Ollama+ChatBox)

Dheeraj Malhotra — Sat, 01 Mar 2025 19:59:23 +0000

At the very beginning:

Recently,DeepSeek has become so popular that everyone wants to give it a try. The arrival of DeepSeek can be said to have sparked a nationwide AI craze.
Initially, I thought deploying DeepSeek locally would be very challenging, but after testing, it turned out to be quite simple. The process is as easy as installing new software on your computer, and it takes only about ten minutes to complete the local deployment.
Today, let's talk about how to deploy the DeepSeek-R1-1.5B model locally on your own computer.
Installation Steps Overview:

Install ServBay: Why install it? Because it allows you to one-click install Ollama and one-click install DeepSeek.

Install a GUI that supports Ollama: Is the command-line interface not user-friendly? Don't worry, we've got the perfect GUI prepared for you.

Start seamless conversations with DeepSeek!

Ⅰ. Why Deploy DeepSeek Locally?

Some of you may share the same experience as me—frequently encountering the message "Server busy, please try again later" when using DeepSeek. However, with local deployment, this issue simply doesn’t exist.

I recommend everyone deploy the DeepSeek-R1-1.5B model. Why this version? Here’s why:

Compact and Efficient :DeepSeek-R1-1.5B is a lightweight model with only 1.5 billion parameters. Sounds “tiny,” right? But don’t underestimate it—this is a “small but mighty” model! It only requires 3GB of VRAM to run, meaning even computers with modest configurations can handle it with ease. Moreover, it performs exceptionally well in mathematical reasoning, even surpassing GPT-4o and Claude 3.5 in some benchmarks. Of course, if your computer has a higher configuration, you can opt for other versions.
Higher Flexibility : Locally deployed large models offer more flexibility as they are usually not limited by external platforms. Users gain complete control over the model's behavior and content.
No Content Censorship : Large models accessed via API calls may face restrictions from the service provider’s content policies (e.g., OpenAI’s ChatGPT limits responses on sensitive topics). However, locally deployed models can be adjusted based on the user's needs, allowing for discussions on a broader range of topics.
Privacy Protection : All data is processed locally without the need for uploading to the cloud, making it suitable for scenarios with high data privacy requirements.
Full Control : Users have complete control over the model’s runtime environment, data inputs and outputs, as well as updates and optimizations of the model.

In summary, local deployment eliminates response failures and significantly enhances user satisfaction. Users with other requirements can refer to the content below for alternative options.

II. Hardware Requirements for Different Versions of DeepSeek

Below are the hardware requirements for different versions of the DeepSeek model. You can choose the version that best matches your computer's configuration.

Ⅲ. Deployment Steps

1. Download ServBay

Requires macOS 12.0 Monterey or later. Currently, they do not support a Windows version, but according to the official statement, it will be available soon.
Download the latest version of ServBay

The installation file is only 20MB.

Installation Steps

Double-click the downloaded .dmg file.
In the opened window, drag the ServBay.app icon into the Applications folder.

When using ServBay for the first time, initialization is required.

One-click selection of Ollama

Once the installation is complete, open ServBay to begin using it.

Enter the password. Once the installation is complete, you can find ServBay in the Applications directory.
Access the main interface. Originally, Ollama required a complex process to install and start services, but with ServBay, you can start with a single click, install the AI models you need, and no longer worry about configuring environment variables. Even ordinary users with no knowledge of development can use it with just one click. One-click start and stop, multi-threaded rapid model downloads, and as long as your macOS system is sufficient, you can run multiple large AI models simultaneously.

Remember Ollama's local path and port number

DeepSeek One-click download for DeepSeek

On my computer, the download speed for DeepSeek8B even exceeded 60MB per second, completely surpassing other similar tools.

With ServBay and Ollama, I was able to deploy DeepSeek locally. Look, it's running smoothly!

This way, we've achieved local deployment of large models using ServBay + Ollama. However, it's currently limited to the command line, and there's no GUI yet!

2. GUI Recommendation - Chatbox (Personally Tested, Best Option)

Chatbox is easy to use (Free, powerful, supports file uploads, Recommendation rating: 🌟🌟🌟🌟🌟).

Chatbox Download

After downloading, access the main interface:

Click on settings and follow the steps to make modifications.

Save changes, and you can start conversations. You'll see that the modifications have been successfully applied.

With this, we've completed the full deployment of the DeepSeek-R1-1.5B model based on ServBay.

Summary:

Friends, isn't it incredibly easy to locally deploy the DeepSeek-R1-1.5B model using ServBay? By following the steps above, it takes only 10 minutes to turn your computer into an "intelligent assistant."

Moreover, this model not only runs efficiently but can also make a big impact in various scenarios. Go ahead and give it a try!