Installing CAI: Bridging the Gap Between ML Theory and Business Applications

Today we're walking you through the tech stack needed to run CAI—our Crypto Predictive AI System—while addressing a fundamental gap in ML education. Estimated read time: 5 minutes.

The Reality Check: What They Don’t Teach You

Most AI courses focus heavily on model training: feature engineering, train/val/test splits, backpropagation, hyperparameter-tuning, activation functions, and loss functions. Each domain requires deep theoretical understanding and practical application—which is already substantial.

But here’s the problem: this is where most university programs stop.

Fresh ML graduates enter the job market confident in their abilities, only to encounter job descriptions filled with unfamiliar requirements: Docker, Kubernetes, Linux, CI/CD pipelines. For traditional engineers who took ML courses to enhance their portfolios, these are completely foreign concepts (though computer science students might be nodding knowingly).

Why the Disconnect?

The answer is simple: different goals drive different priorities:

• Companies are market-driven. Software that can’t be deployed is worthless. Period.

• Universities are research-driven. They optimize for discovery and development, not deployment. As long as the code runs in a Jupyter Notebook or Python scripts in VS Code, the research objective is met.

Add to this the breakneck pace of AI tooling evolution—new IDEs with agentic integration, deployment frameworks, and countless other tools appearing monthly—and it’s nearly impossible for students and early-career engineers to know what to prioritize.

Making Sense of ML Engineering

Here’s how to think about it:

ML Engineering = Software Engineering + Applied Engineering.

More specifically, it’s the DevOps side of software engineering combined with any field teaching advanced math and programming (mechanical, electrical, mathematics, physics).

If you come from software engineering:

You likely know many of the tools we’ll cover. Your focus should be diving deeper into mathematics or applied domains. Companies need ML engineers who understand complex use cases—financial markets, autonomous vehicles, medical imaging. HTML, CSS, and JavaScript won’t take you far here.

If you come from applied engineering:

Learn the software integration side. Want to join an automotive manufacturer’s computer vision team? Study how to integrate ML solutions into production systems, containerization, and orchestration.

Regardless of your background: just start.

The CAI Tech Stack

Now to get a bit more hands-on with what we’ve done at Mirai Engineering: Here’s what powers CAI on the MLOps and software side, as well as other tools to keep in mind.

Core Development Tools

• Unix/Shell/Makefiles/Python: Essential for scripting, automation, and orchestration. These are the foundation of any ML pipeline.

• Rust/Go/C++: High-performance languages for building efficient APIs and servers that handle real-time data streams.

• ONNX: The standard for model interoperability, allowing you to train in one framework and deploy in another.

• GitHub: Version control and collaboration platform for tracking code changes, managing contributions, and hosting your project’s source code.

Deployment Infrastructure

• Docker: Containerization ensures your models run consistently across any environment.

• Kubernetes (kind): Orchestrates containers at scale, managing deployment, scaling, and operations.

CAI Installation Guide

If you want to play around with CAI just follow this installation guideline. If you don’t have the link to the repo, here it is:

https://github.com/mirai-engineering/CAI-CryptoPredictiveAI/

Prerequisites

This project uses uv—the fastest and most reliable Python environment manager available.

Step 1: Clone and Install Dependencies

# Clone the repository 

git clone https://github.com/mirai-engineering/CAI-CryptoPredictiveAI 
cd CryptoPredictiveAI 

# Install all workspace dependencies 
uv sync 

# Install individual service dependencies 

uv add services/candles 
uv add services/technical_indicators 
uv add services/news 
uv add services/news_sentiment 
uv add services/predictor

---

Step 2: Set Up Kubernetes Cluster

This is where Unix and shell scripting knowledge pays off. Before running these commands, ensure they’re executable:

chmod +x deployments/dev/kind/*.sh

Then create and configure your cluster:

# Create local kind cluster with port mappings
cd deployments/dev/kind
./create_cluster.sh

# Install infrastructure components
./install_kafka.sh        # Message streaming
./install_risingwave.sh   # Stream processing
./install_mlflow.sh       # Model tracking
./install_grafana.sh      # Monitoring

---

Step 3: Build and Deploy Services

The project includes pre-configured Docker images. We recommend reviewing them before proceeding (we’ll cover Docker in detail in a future newsletter). If Makefiles are new to you, take a moment to understand their purpose—they’re simple but powerful automation tools.

# Build and push Docker image
make build-and-push service=<service_name> env=<environment>

# Deploy all services to Kubernetes
make deploy service=<service_name> env=<environment>

Next time on the CAI series: We’ll dive into the architecture of CAI’s microservices and how they communicate through Kafka streams.

Questions? You’re probably not the only one! Leave a comment or share what you think.