Skip to main content

Deploying with Git

You can use git push to create and manage your ML deployments. This is often a good fit for projects with with already pickled dependencies or complex directories of Python source files.

To create a new deployment, clone to your Modelbit git repository and create a new directory under deployments/. The name of the directory will be the name of your deployment. Use only letters, numbers, and underscores in the directory name.


Create your first deployment using mb.deploy(...) in a notebook, then modify the generated files to simplify deployment configuration via git.

Required files

Then create the following three files within your new directory:

1. requirements.txt

This file defined the Python packages your deployment requires, and will be installed using pip. For example:



This file is the entrypoint for executing your model. For local testing, you can read arguments from the command line (like the example below). In production the main function will be called directly. For example:

import sys

# main function
def my_deploy_function(foo: int):
return 2 * foo

# to run locally via git & terminal
if __name__ == "__main__":

3. metadata.yaml

This is the last file Modelbit needs in order to deploy your model. It defines which method to call in, the argument types to expect, and the environment to create.

Learn more about this file in the metadata.yaml docs.


To deploy, git add and git commit these three files, then git push to Modelbit! Your new deployment will appear in the deployments tab.

Additional Python source files

If you have additional source files, import them in and call their functions from within the main function of the deployment (in this case, my_deploy_function). For example:

def double_a_number(num: int):
return 2 * num

And, the new

from helpers import double_a_number

def my_deploy_function(foo: int):
return double_a_number(foo)

Including .pkl dependencies

Likewise if you have .pkl files you'll want to load in your production environment simply add them to git in this directory. For example, we'll load model.pkl for making predictions:

import pickle

with open("model.pkl", "rb") as f:
model = pickle.load(f)

def my_deploy_function(foo: int):
return model.predict([[foo]])[0]

Testing locally

Modelbit's deployment environments import and run the deployment function (vs. executing directly). You can reproduce Modelbit's runtime behavior locally, and uncover issues, by testing that the deploy function will run when imported:

Testing using a notebook

Create a notebook in the same directory as, and then import and run your deployment function:

import source

Testing using the command line

Create a new file,, in the same directory as and then import and run your deployment function within the __main__ block:

if __name__ == "__main__":
import source

Then call python from the command line.


To archive a deployment add a empty .archived file in that deployment's directory. For example, for a deployment named doubler you'd make the file deployments/doubler/.archived.

When you git push that deployment will be archived on the current branch.