Ai Django Integration | AI Final Year Project Report

Complete Technical Paper Content — Ai Django Integration

1. Executive Abstract, Problem Formulation & Background

The Python programming language is actively used by many people, both in industry and academia, for a wide variety of purposes.

Atom — an open-source cross-platform IDE with autocomplete, help and more Python features under package extensions. Codelobster — a cross-platform IDE for various languages, including Python. Colab — Jupyter notebook online integrated development environment developed by Google. EasyEclipse — an open-source IDE for Python and other languages. Eclipse — with the Pydev plug-in. Eclipse supports many other languages as well. Emacs, with the built-in python-mode. Eric — an IDE for Python and Ruby. Geany — IDE for Python development and other languages. IDLE — a simple IDE bundled with the default implementation of the language. Jupyter Notebook — an IDE that supports markdown, Python, Julia — R and several other languages. Kaggle Notebooks — an online IDE for Python and R with integrated data science libraries, free GPUs, and collaborative features. Komodo IDE — an IDE PHOTOS Python, Perl, PHP and Ruby. Neovim — has python support with pynvim. NetBeans — is written in Java and runs everywhere where a JVM is installed. PyCharm — a proprietary and open-source IDE for Python development. PythonAnywhere — an online IDE and Web hosting service. Python Tools for Visual Studio — Free and open-source plug-in for Visual Studio. Spyder — IDE for scientific programming. Thonny — beginner-friendly Python IDE. Vim — with "lang#python" layer enabled. Visual Studio Code — an open-source IDE for various languages, including Python. Wing IDE — cross-platform proprietary with some free versions/licenses IDE for Python. Replit — an online IDE that supports multiple languages.

BlueBream – a rewrite by the Zope developers of the Zope 2 web application server. CherryPy – an object-oriented web application server and framework. CubicWeb – a web framework that targets large-scale semantic web and linked open data applications and international corporations. Django – an MVT (model, view, template) web framework. Flask – a modern, lightweight, well-documented micro-framework based on Werkzeug and Jinja 2. Google App Engine – a platform for developing and hosting web applications in Google-managed data centers, including Python. Grok – a web framework based on Zope Toolkit technology. Nevow – a web application framework originally developed by the company Divmod. Pylons – a lightweight web framework emphasizing flexibility and rapid development. Pyramid – a minimalistic web framework inspired by Zope, Pylons and Django. Quixote – a framework for developing Web applications in Python. RapidSMS – a web framework which extends the logic and capabilities of Django to communicate with SMS messages. Spyce – a technology to embed Python code into webpages. Tornado – a lightweight non-blocking server and framework. TurboGears – a web framework combining SQLObject/SQLAlchemy, Kid/Genshi, and CherryPy/Pylons. web2py – a full-stack enterprise web application framework, following the MVC design. Zope 2 – an application server, commonly used to build content management systems.

Apache MXNet — open-source deep learning framework for deep neural networks. Apache Singa — library for deep learning. Apache SystemDS — machine learning system for the end-to-end data science lifecycle. Caffe — deep learning framework. CatBoost — machine learning library for gradient boosting on decision trees. Chainer — deep learning framework on top of NumPy and CuPy. Deeplearning4j — open-source deep learning library for the Java virtual machine. DeepSpeed — deep learning optimization library. Dlib — software library with machine learning algorithms. fastText — library for efficient text classification and word embeddings. Gensim — library for topic modeling and vector space modeling. H2O — software for machine learning and predictive analytics. Horovod — framework by Uber for distributed deep learning training using TensorFlow, Keras, PyTorch, and Apache MXNet. Hugging Face Transformers — deep learning library for training and running pretrained transformer models. JAX — software library for machine learning, artificial intelligence, and high-performance numerical computing. Jubatus — platform for distributed online machine learning. Keras — high-level neural networks API, running on top of TensorFlow and other backends. LightGBM — gradient boosting framework. MindSpore — deep learning framework developed by Huawei. Orange — open-source data visualization, machine learning, and data mining toolkit. PlaidML — tensor compiler. PyTorch — open-source machine learning library based on the Torch library. PyTorch Lightning — provides a high-level interface for PyTorch. QLattice — symbolic regression. scikit-learn — library for machine learning. Spark MLlib — distributed machine learning library for Apache Spark. TensorFlow — software library for machine learning and artificial intelligence. Theano — machine learning library. Transformers Library — mainly compatible with the PyTorch library from Hugging Face. Vowpal Wabbit — machine learning system for fast online learning. XGBoost — gradient boosting library.

Abaqus (Finite Element Software) ADvantage Framework Amarok ArcGIS – a prominent GIS platform, allows extensive modelling using Python. Autodesk Maya – a professional 3D modeler allows Python scripting as an alternative to MEL as of version 8.5. Autodesk MotionBuilder Autodesk Softimage (formerly Softimage|XSI) BioNumerics – a bioinformatics software suite for the management, storage and (statistical) analysis of all types of biological data. Blender Boxee – a cross-platform home theater PC software. Cinema 4D Civilization IV has the map editor supporting Python. Corel Paint Shop Pro Claws Mail with Python plugin DSHub ERDAS Imagine FL Studio – a Digital audio workstation, uses Python to support MIDI Controller integration, as well as scripting within its piano roll and Edison audio editor. FreeCAD gedit GIMP GNAT – The GNAT programming chain tool (Ada language implementation in GNU gcc), as a GNATcoll reusable components for the applications (with or without PyGTK) and as a scripting language for the commands in the GPS programming environment. Houdini highly evolved 3D animation package, fully extensible using python. Inkscape – a free vector graphics editor. Krita – a free raster graphics editor for digital painting. MeVisLab – a medical image processing and visualization software, uses Python for network scripting, macro modules, and application building. Modo Minecraft: Pi Edition (game). MSC.Software's CAE packages: Adams, Mentat, SimXpert. MySQL Workbench – a visual database design tool. Nuke (compositing for visual effects) OriginPro – a commercial graphic and analysis software, provides Python environment for access. ParaView, an opensource scientific visualization software Poser – a 3D rendering and animation computer program that uses for scripting a special dialect of Python, called PoserPython. PTV AG products for traffic and transportation analysis, including PTV VISSIM. PyMOL – a popular molecular viewer that embeds Python for scripting and integration. OriginPro – a commercial graphing and analysis software, provides a Python environment for both embedded and external access. QGIS uses Python for scripting and plugin-development. Rhinoceros 3D version 5.0 and its visual-scripting language Grasshopper uses IronPython. Rhythmbox Scribus 3DSlicer – a medical image visualisation and analysis software. Python is available for algorithm implementation, analysis pipelines, and GUI creation. SPSS statistical software – SPSS Programmability Extension allows users to extend the SPSS command syntax language with Python. SublimeText Totem – a media player for the GNOME desktop environment. Vim VisIt WeeChat – a console IRC client.

CLPython – Implementation, written in Common Lisp. CPython – The reference implementation, written in C11. Some notable distributions include: ActivePython – Distribution with more than 300 included packages. Intel Distribution for Python – High performance distribution with conda and pip package managers. PSF Python – Reference distribution that includes only selected standard libraries Cython – programming language to simplify writing C and C++ extension modules for the CPython Python runtime. IronPython – Python for CLI platforms (including .NET and Mono). Jython – Python for Java platforms. MicroPython – Python 3 implementation for micro-controller platforms. Nuitka – a source-to-source compiler which compiles Python code to C/C++ executables, or source code. Numba – NumPy aware LLVM-based JIT compiler. PyPy – Python (originally) coded in Python, used with RPython, a restricted subset of Python that is amenable to static analysis and thus a JIT. Shed Skin – a source-to-source compiler from Python to C++. Historic Python implementations include:

2. Related Work, Literature Survey & Algorithmic Foundations

Parrot – Virtual machine being developed mainly as the runtime for Raku, and intended to support dynamic languages like Python, Ruby, Tcl, etc. Psyco – specialized JIT compiler project that has mostly been eclipsed by PyPy. Pyrex – Python-like Python module development project that has mostly been eclipsed by Cython. Python for S60 – CPython port to the S60 platform. Stackless Python – CPython with coroutines. Unladen Swallow – performance-orientated implementation based on CPython which natively executed its bytecode via an LLVM-based JIT compiler. Funded by Google, stopped circa 2011.

Anaconda is an open source data science and artificial intelligence development portal and a distribution platform for the Python programming language. Developed by Anaconda, Inc., an American company founded in 2012, the platform is used to develop and manage data science and AI projects. In 2024, Anaconda Inc. has about 300 employees and 50 million users.

Anaconda Navigator is a desktop graphical user interface (GUI) included in Anaconda distribution that allows users to launch applications and manage Conda packages, environments and channels without using command-line commands. Navigator can search for packages on Anaconda Cloud or in a local Anaconda Repository, install them in an environment, run the packages and update them. It is available for Windows, macOS and Linux. The following applications are available by default in Navigator:

Conda is an open source, cross-platform, language-agnostic package manager and environment management system that installs, runs, and updates packages and their dependencies. It was created for Python programs, but it can package and distribute software for any language, including multi-language projects. The Conda package and environment manager is included in all versions of Anaconda, Miniconda, and Anaconda Repository.

AI/ML Learning Roadmap with Django Integration 1. Beginner Level Topics: Basic AI/ML Concepts What is AI/ML, and how does it differ from traditional programming? Overview of Python libraries for AI/ML: NumPy, Pandas, scikit-learn, TensorFlow, PyTorch. Setting Up the Environment Installing essential libraries: scikit-learn, TensorFlow, NumPy, Pandas. Setting up Django with a virtual environment. Building and Saving Simple ML Models Basics of building a model in scikit-learn (e.g., regression or classification). Exporting models using joblib or pickle. Integrating ML with Django Creating a Django view to load and use a pre-trained model. Using forms to take user input and return predictions. Suggestions: Learn basic ML by following tutorials like Hands-On Machine Learning with scikit-learn . Practice deploying small ML scripts as standalone Python projects before integrating them with Django. Hands-On: Build a House Price Predictor: Train a simple regression model to predict house prices based on features like area and location. Create a Django app where users can input house details and get predictions. 2. Intermediate Level Topics: Handling Larger ML Models Building and deploying more complex ML models (e.g., neural networks with TensorFlow). Loading large models efficiently into Django apps. REST API Integration Using Django Rest Framework (DRF) to expose ML predictions via APIs. Building APIs for model inference. Preprocessing User Input Adding preprocessing steps for user inputs (e.g., feature scaling, one-hot encoding). Validating and sanitizing inputs before predictions. Real-Time Predictions Implementing AJAX or WebSocket-based frontends for real-time predictions. Simple AI Models Sentiment analysis or text classification using libraries like nltk or TextBlob. Suggestions: Explore libraries like Flask for lightweight AI APIs and compare them with Django for ML integration. Practice creating reusable APIs for different ML tasks. Hands-On: Build a Sentiment Analysis App: Train a model to classify text as positive, negative, or neutral. Create a Django-based web app where users can enter text and see the sentiment. 3. Advanced Level Topics: Deploying Models with Django Using cloud services (AWS S3, Azure, GCP) to host models. Deploying Django with Docker and including pre-trained models. Dynamic Model Updates Allowing models to update dynamically based on new data. Using Django ORM to log user inputs and predictions for retraining. Asynchronous Predictions Running long-running ML tasks asynchronously using Celery. Returning results to the frontend when the prediction is ready. ML Pipelines Integrating pre-built pipelines (e.g., TensorFlow SavedModel or PyTorch TorchScript). Using tools like ONNX for cross-platform model deployment. Model Monitoring and Logging Tracking model performance over time. Logging user inputs and outputs for further improvements. Suggestions: Learn about containerization using Docker to simplify model deployments. Explore how Celery can be used to handle heavy prediction loads. Hands-On: Build a Recommendation System: Train a recommendation model (e.g., collaborative filtering) for products or movies. Host the model in Django and provide recommendations via REST APIs. 4. Professional Level Topics: Real-Time ML with Django Channels Integrating WebSockets for real-time ML predictions. Building real-time dashboards for visualizing predictions. Microservices Architecture Hosting ML models as separate microservices. Communicating between Django and ML microservices using REST APIs or gRPC. Advanced AI Models Using deep learning models (e.g., BERT for NLP, CNNs for image processing). Deploying pre-trained models from libraries like Hugging Face or TensorFlow Hub. Scaling ML Deployments Scaling model inference using Kubernetes or serverless functions. Using load balancers to distribute prediction requests. Model Versioning and Retraining Managing multiple versions of a model (e.g., with MLflow or DVC). Retraining models on new data without interrupting the system. AI Explainability Integrating tools like SHAP or LIME for explaining model predictions. Providing interpretable results to end users. Suggestions: Explore advanced deployment platforms like AWS SageMaker or Azure ML. Dive into distributed systems and AI model optimization. Hands-On: Build a Real-Time Fraud Detection System: Use a pre-trained model to classify transactions as fraudulent or safe. Build a real-time alert system with Django Channels for fraud detection. Project Ideas Across Levels: Beginner: Spam Email Classifier Train a Naive Bayes classifier to detect spam emails. Build a simple Django web app where users paste email content and get predictions. Intermediate: Image Classification App Train a CNN on a dataset like CIFAR-10 or MNIST. Allow users to upload images and classify them using the model. Advanced: Custom Chatbot Train a chatbot using a Transformer model like GPT or BERT. Deploy it in a Django web app with real-time responses. Professional: Predictive Maintenance System Use time-series data to predict equipment failures. Build a full-stack application with a monitoring dashboard for predictions. Deployment Options: Basic: Deploy on platforms like PythonAnywhere or Heroku. Intermediate: Use Docker to containerize the Django app and ML model. Advanced: Deploy on AWS (Elastic Beanstalk + SageMaker) or GCP. Professional: Build CI/CD pipelines with Kubernetes for scalable deployments.

ML Django Brain A Django plugin for AI/ML integration that provides model registry, API integration, performance optimization, and monitoring capabilities for machine learning models in Django applications. Features Model Registry and Management : Register, version, and manage ML models with support for different formats (scikit-learn, TensorFlow, PyTorch) Simplified API Integration : Automatic REST API generation for ML models with standardized input/output serialization Performance Optimization : Model caching mechanisms and batch prediction capabilities Monitoring and Logging : Track model performance metrics and prediction logging Table of Contents Author Example Project Installation Quick Start Architecture Components API Reference Supported ML Frameworks Configuration Contributing License Author Saeed Ghanbari - GitHub Example Project The plugin includes an example project that demonstrates its usage. Here's a preview of what it looks like: To run the example: Clone the repository: git clone https://github.com/sgh370/ml-django-brain.git cd ml-django-brain Create a virtual environment and install dependencies: python -m venv venv source venv/bin/activate # On Windows: venv\Scripts\activate pip install -e . cd example_project pip install -r requirements.txt Run migrations: python manage.py migrate Create a superuser: python manage.py createsuperuser Train and register the example model: python manage.py train_iris_model Run the development server: python manage.py runserver Access the example project at http://localhost:8000/ Admin Access You can access the admin interface at http://localhost:8000/admin/ with: Username : admin Password : admin123 Example API Endpoints List all models: /api/models/ Get model details: /api/models/<id>/ Make a prediction: /api/models/<id>/predict/ Make batch predictions: /api/models/<id>/batch_predict/ Installation pip install ml-django-brain Quick Start Add ml_django_brain to your INSTALLED_APPS in settings.py: INSTALLED_APPS = [ # ... 'rest_framework' , # Required dependency 'ml_django_brain' , # ... ] # ML Django Brain settings ML_DJANGO_BRAIN = { 'STORAGE_DIR' : os . path . join ( MEDIA_ROOT , 'ml_models' ), 'CACHE_ENABLED' : True , 'LOG_PREDICTIONS' : True , } Add the URLs to your project's urls.py: from django . urls import path , include urlpatterns = [ # ... path ( 'api/' , include ( 'ml_django_brain.urls' , namespace = 'ml_django_brain' )), # ... ] Run migrations: python manage.py migrate Register your first model: from ml_django_brain . registry import ModelRegistry import sklearn . ensemble # Train your model model = sklearn . ensemble . RandomForestClassifier () model . fit ( X_train , y_train ) # Register the model registry = ModelRegistry () registry . register ( name = "my_classifier" , model = model , version = "1.0.0" , input_schema = { "title" : "Input Schema" , "type" : "object" , "properties" : { "feature1" : { "type" : "number" }, "feature2" : { "type" : "number" } } }, output_schema = { "title" : "Output Schema" , "type" : "object" , "properties" : { "prediction" : { "type" : "string" } } } ) Use the model in your views: from ml_django_brain . services import PredictionService from django . http import JsonResponse def predict_view ( request ): service = PredictionService () prediction = service . predict ( "my_classifier" , { "feature1" : 0.5 , "feature2" : 0.7 }) return JsonResponse ( prediction ) Architecture ML Django Brain follows a modular architecture with the following key components: Model Registry : Central system for registering, versioning, and retrieving ML models Prediction Service : Handles model inference with input validation and output formatting API Layer : REST API endpoints for model management and predictions Monitoring System : Tracks model performance and logs predictions Components Core Models MLModel : Stores metadata about machine learning models ModelVersion : Manages different versions of a model PredictionLog : Logs predictions made by models ModelMetric : Tracks performance metrics for model versions Services ModelRegistry : Singleton class for model management PredictionService : Handles model inference ModelMetricsCalculator : Calculates and records model performance metrics Utilities ModelLoader : Loads models from different formats ModelSerializer : Serializes models to different formats InputOutputSerializer : Handles serialization of inputs and outputs Management Commands register_model : Register a model from a file list_models : List all registered models evaluate_model : Evaluate a model on a test dataset API Reference REST API Endpoints GET /api/models/ : List all registered models GET /api/models/{id}/ : Get details of a specific model POST /api/models/{id}/predict/ : Make a prediction using a model POST /api/models/{id}/batch_predict/ : Make batch predictions GET /api/versions/ : List all model versions GET /api/logs/ : List prediction logs GET /api/metrics/ : List model metrics Python API # Registry API from ml_django_brain . registry import ModelRegistry registry = ModelRegistry () registry . register ( name , model , version , description , input_schema , output_schema , metrics ) registry . load_model ( name , version = None ) registry . get_model_info ( name ) registry . list_models () registry . delete_model ( name ) # Prediction API from ml_django_brain . services import PredictionService service = PredictionService () result = service . predict ( model_name , input_data , version = None , log_prediction = True ) results = service . batch_predict ( model_name , input_data_list , version = None , log_predictions = True ) # Metrics API from ml_django_brain . utils . metrics import ModelMetricsCalculator metrics = ModelMetricsCalculator . calculate_classification_metrics ( y_true , y_pred , y_prob ) metrics = ModelMetricsCalculator . calculate_regression_metrics ( y_true , y_pred ) MetricsCalculator . record_metrics ( model_version , metrics ) Supported ML Frameworks ML Django Brain supports the following machine learning frameworks: scikit-learn : Full support for all model types TensorFlow/Keras : Support for saved models and h5 files PyTorch : Support for saved models (.pt/.pth files) XGBoost : Support for all model types LightGBM : Support for all model types CatBoost : Support for all model types ONNX : Support for ONNX format models Configuration ML Django Brain can be configured through the ML_DJANGO_BRAIN dictionary in your Django settings: ML_DJANGO_BRAIN = { # Storage directory for ML models 'STORAGE_DIR' : os . path . join ( MEDIA_ROOT , 'ml_models' ), # Cache settings 'CACHE_ENABLED' : True , 'CACHE_TIMEOUT' : 3600 , # 1 hour in seconds # Logging settings 'LOGGING_ENABLED' : True , 'LOG_PREDICTIONS' : True , 'LOG_LEVEL' : 'INFO' , # Performance settings 'BATCH_SIZE' : 32 , 'ASYNC_PREDICTION' : False , # Monitoring settings 'DRIFT_DETECTION_ENABLED' : True , 'DRIFT_THRESHOLD' : 0.1 , # 10% change # API settings 'API_AUTHENTICATION_REQUIRED' : True , 'API_THROTTLE_RATE' : '100/hour' , } Contributing Contributions are welcome! Please feel free to submit a Pull Request. Fork the repository Create your feature branch ( git checkout -b feature/amazing-feature ) Commit your changes ( git commit -m 'Add some amazing feature' ) Push to the branch ( git push origin feature/amazing-feature ) Open a Pull Request License MIT

3. Dataset Ingestion, Preprocessing & Stochastic Augmentations

A Django plugin for AI/ML integration that provides model registry, API integration, performance optimization, and monitoring capabilities for machine learning models in Django applications.

The plugin includes an example project that demonstrates its usage. Here's a preview of what it looks like:

python -m venv venv source venv/bin/activate # On Windows: venv\Scripts\activate pip install -e . cd example_project pip install -r requirements.txt

INSTALLED_APPS = [ # ... 'rest_framework' , # Required dependency 'ml_django_brain' , # ... ] # ML Django Brain settings ML_DJANGO_BRAIN = { 'STORAGE_DIR' : os . path . join ( MEDIA_ROOT , 'ml_models' ), 'CACHE_ENABLED' : True , 'LOG_PREDICTIONS' : True , }

from django . urls import path , include urlpatterns = [ # ... path ( 'api/' , include ( 'ml_django_brain.urls' , namespace = 'ml_django_brain' )), # ... ]

from ml_django_brain . registry import ModelRegistry import sklearn . ensemble # Train your model model = sklearn . ensemble . RandomForestClassifier () model . fit ( X_train , y_train ) # Register the model registry = ModelRegistry () registry . register ( name = "my_classifier" , model = model , version = "1.0.0" , input_schema = { "title" : "Input Schema" , "type" : "object" , "properties" : { "feature1" : { "type" : "number" }, "feature2" : { "type" : "number" } } }, output_schema = { "title" : "Output Schema" , "type" : "object" , "properties" : { "prediction" : { "type" : "string" } } } )

4. Neural Network Backbone, Layer Specifications & Loss Formulations

from ml_django_brain . services import PredictionService from django . http import JsonResponse def predict_view ( request ): service = PredictionService () prediction = service . predict ( "my_classifier" , { "feature1" : 0.5 , "feature2" : 0.7 }) return JsonResponse ( prediction )

# Registry API from ml_django_brain . registry import ModelRegistry registry = ModelRegistry () registry . register ( name , model , version , description , input_schema , output_schema , metrics ) registry . load_model ( name , version = None ) registry . get_model_info ( name ) registry . list_models () registry . delete_model ( name ) # Prediction API from ml_django_brain . services import PredictionService service = PredictionService () result = service . predict ( model_name , input_data , version = None , log_prediction = True ) results = service . batch_predict ( model_name , input_data_list , version = None , log_predictions = True ) # Metrics API from ml_django_brain . utils . metrics import ModelMetricsCalculator metrics = ModelMetricsCalculator . calculate_classification_metrics ( y_true , y_pred , y_prob ) metrics = ModelMetricsCalculator . calculate_regression_metrics ( y_true , y_pred ) MetricsCalculator . record_metrics ( model_version , metrics )

ML Django Brain can be configured through the ML_DJANGO_BRAIN dictionary in your Django settings:

ML_DJANGO_BRAIN = { # Storage directory for ML models 'STORAGE_DIR' : os . path . join ( MEDIA_ROOT , 'ml_models' ), # Cache settings 'CACHE_ENABLED' : True , 'CACHE_TIMEOUT' : 3600 , # 1 hour in seconds # Logging settings 'LOGGING_ENABLED' : True , 'LOG_PREDICTIONS' : True , 'LOG_LEVEL' : 'INFO' , # Performance settings 'BATCH_SIZE' : 32 , 'ASYNC_PREDICTION' : False , # Monitoring settings 'DRIFT_DETECTION_ENABLED' : True , 'DRIFT_THRESHOLD' : 0.1 , # 10% change # API settings 'API_AUTHENTICATION_REQUIRED' : True , 'API_THROTTLE_RATE' : '100/hour' , }

A Django plugin for AI/ML integration that provides model registry, API integration, performance optimization, and monitoring capabilities for machine learning models in Django applications.

django-ai-assistant Combine the power of LLMs with Django's productivity to build intelligent applications. Let AI Assistants call methods from Django's side and do anything your users need! Use AI Tool Calling and RAG with Django to easily build state of the art AI Assistants. Please check the documentation: https://vintasoftware.github.io/django-ai-assistant/ 5 minute demo demo-ai-assistant.mp4 Community Feel free to ask questions and share your work on our Discord Server ! Contributing You're welcome to contribute with Django AI Assistant! Please feel free to tackle existing issues . If you have a new idea, please create a thread on Discussions . Check our contributing guide to learn more about how to develop and test the project locally, before opening a pull request. Commercial Support This is an open-source project maintained by Vinta Software . We are always looking for exciting work! If you need any commercial support, feel free to get in touch: contact@vinta.com.br

5. Training Protocol, Convergence Behavior & Experimental Evaluation

Combine the power of LLMs with Django's productivity to build intelligent applications. Let AI Assistants call methods from Django's side and do anything your users need!

Use AI Tool Calling and RAG with Django to easily build state of the art AI Assistants.

You're welcome to contribute with Django AI Assistant! Please feel free to tackle existing issues . If you have a new idea, please create a thread on Discussions .

Check our contributing guide to learn more about how to develop and test the project locally, before opening a pull request.

This is an open-source project maintained by Vinta Software . We are always looking for exciting work! If you need any commercial support, feel free to get in touch: contact@vinta.com.br

Django AI Core Developer-focused package for implementing AI tooling into Django sites. Django AI Core provides core functionality for interacting with LLMs in your Django project, as well as optional modules for building AI-powered apps. TODO Core: Logging for LLM requests Async/streaming support Agents: Rate limiting Streaming responses Index: Test different backends Docs Higher-level API? Chat: Build Chat/RAG module with chat UI MCP: Build MCP 'function' registry