Python SDK for AI agent monitoring, LLM cost tracking, benchmarking, and more. Integrates with most LLMs and agent frameworks including CrewAI, Agno, OpenAI Agents SDK, Langchain, Autogen, AG2, and CamelAI
Python agentagentopsagents-sdkaianthropicautogencost-estimationcrewaievalsevaluation-metricsgroqlangchainllmmistralollamaopenaiopenai-agents
---
title: "Just Commands Reference"
description: "Complete reference for all available Just commands in AgentOps development"
---
# Just Commands Reference
[Just](https://github.com/casey/just) is a command runner that provides convenient shortcuts for common development tasks. The AgentOps project includes a comprehensive `justfile` with commands for setup, development, testing, and deployment.
## Installation
First, install Just if you haven't already:
```bash
# macOS
brew install just
# Linux (using cargo)
cargo install just
# Or download from GitHub releases
curl --proto '=https' --tlsv1.2 -sSf https://just.systems/install.sh | bash -s -- --to ~/bin
```
## Quick Reference
View all available commands:
```bash
just
# or
just --list
```
## Setup Commands
### `just setup`
Complete development environment setup - runs the full initialization process.
```bash
just setup
```
**What it does:**
- Copies environment files (`.env.example` → `.env`, etc.)
- Installs all dependencies (root, API, dashboard)
- Sets up development environment
**Use when:**
- First time setting up the project
- After a fresh clone
- When you want to reset your development environment
### `just install`
Install all project dependencies across all services.
```bash
just install
```
**What it does:**
- Installs root Node.js dependencies (`bun install`)
- Installs Python development dependencies (`uv pip install -r requirements-dev.txt`)
- Installs API dependencies (`cd api && uv pip install -e .`)
- Installs dashboard dependencies (`cd dashboard && bun install`)
**Use when:**
- After pulling changes that modify dependencies
- When `package.json`, `pyproject.toml`, or requirements files change
## API Development Commands
### `just api-native`
Run the API server natively (fastest for development).
```bash
just api-native
```
**What it does:**
- Starts the FastAPI server using `uv run python run.py`
- Runs on `http://localhost:8000`
- Provides fastest reload times for development
**Use when:**
- Active API development
- You need fastest iteration cycles
- Debugging API code
### `just api-build`
Build the API Docker image.
```bash
just api-build
# With Stripe support
just api-build stripe
```
**What it does:**
- Builds Docker image for the API service
- Uses `./scripts/just-api-build.sh`
- Optional Stripe integration support
**Use when:**
- Preparing for Docker-based deployment
- Testing Docker build process
- Before running `just api-run`
### `just api-run`
Run the API server in a Docker container.
```bash
just api-run
# With Stripe support
just api-run stripe
```
**What it does:**
- Runs the API service using Docker
- Uses `./scripts/just-api-run.sh`
- Includes all necessary environment variables
- Optional Stripe integration
**Use when:**
- Testing Docker deployment locally
- You need isolated environment
- Production-like testing
### `just api-test`
Run API tests using pytest.
```bash
just api-test
```
**What it does:**
- Changes to `api/` directory
- Runs `pytest` with all configured tests
- Includes unit and integration tests
**Use when:**
- Before committing API changes
- Validating API functionality
- Continuous integration
## Frontend Development Commands
### `just fe-run`
Run the dashboard development server.
```bash
just fe-run
```
**What it does:**
- Changes to `dashboard/` directory
- Installs dependencies (`bun install`)
- Starts development server (`bun run dev`)
- Available at `http://localhost:3000`
**Use when:**
- Active dashboard development
- Testing frontend changes
- Full-stack development
### `just fe-build`
Build the dashboard for production.
```bash
just fe-build
```
**What it does:**
- Changes to `dashboard/` directory
- Builds optimized production bundle (`bun run build`)
- Generates static assets
**Use when:**
- Preparing for production deployment
- Testing production build locally
- Performance optimization
### `just fe-test`
Run frontend tests.
```bash
just fe-test
```
**What it does:**
- Changes to `dashboard/` directory
- Runs test suite (`bun test`)
- Includes unit and component tests
**Use when:**
- Before committing frontend changes
- Validating UI functionality
- Continuous integration
## Code Quality Commands
### `just lint`
Run all linting checks across the project.
```bash
just lint
```
**What it does:**
- Runs `bun run lint` from project root
- Checks JavaScript/TypeScript files with ESLint
- Checks Python files with Ruff
- Validates code style and quality
**Use when:**
- Before committing changes
- Code review preparation
- Maintaining code quality
### `just format`
Format all code using project standards.
```bash
just format
```
**What it does:**
- Runs `ruff format` for Python files
- Applies consistent code formatting
- Fixes automatically correctable issues
**Use when:**
- Before committing changes
- Standardizing code style
- Preparing for code review
### `just test`
Run all tests across the project.
```bash
just test
```
**What it does:**
- Runs `just api-test` (API tests)
- Runs `just fe-test` (frontend tests)
- Comprehensive test suite execution
**Use when:**
- Before major releases
- Validating entire system
- Continuous integration
## Docker Management Commands
### `just up`
Start all services with Docker Compose.
```bash
just up
```
**What it does:**
- Runs `docker-compose up -d`
- Starts all defined services in detached mode
- Creates networks and volumes as needed
**Use when:**
- Starting development environment
- Testing full system integration
- Docker-based development
### `just down`
Stop all Docker services.
```bash
just down
```
**What it does:**
- Runs `docker-compose down`
- Stops and removes containers
- Preserves volumes and networks
**Use when:**
- Stopping development environment
- Switching between development modes
- Cleaning up running services
### `just logs`
View Docker logs for all services.
```bash
just logs
```
**What it does:**
- Runs `docker-compose logs -f`
- Shows real-time logs from all services
- Useful for debugging and monitoring
**Use when:**
- Debugging service issues
- Monitoring application behavior
- Troubleshooting problems
### `just clean`
Clean up Docker resources.
```bash
just clean
```
**What it does:**
- Runs `docker-compose down -v` (stops services and removes volumes)
- Runs `docker system prune -f` (removes unused Docker resources)
- Frees up disk space
**Use when:**
- Cleaning up development environment
- Freeing disk space
- Resolving Docker issues
- Fresh start needed
## Command Combinations and Workflows
### Full Development Setup
```bash
# First time setup
just setup
# Start development
just api-native # Terminal 1
just fe-run # Terminal 2
```
### Docker Development
```bash
# Setup and start with Docker
just setup
just up
just logs
```
### Testing Workflow
```bash
# Run quality checks before committing
just lint
just format
just test
```
### Production Preparation
```bash
# Build and test production assets
just api-build
just fe-build
just test
```
## Environment-Specific Usage
### Development Environment
```bash
# Fast iteration cycle
just api-native # Native API for speed
just fe-run # Frontend dev server
```
### Integration Testing
```bash
# Full Docker environment
just up # All services in Docker
just test # Run full test suite
```
### Production Testing
```bash
# Production-like environment
just api-build # Build production API image
just fe-build # Build production frontend
just up # Run with Docker
```
## Troubleshooting Just Commands
### Command Not Found
```bash
# Verify Just is installed
just --version
# Install if missing
brew install just # macOS
```
### Permission Issues
```bash
# Make sure justfile is executable
chmod +x justfile
# Check file permissions
ls -la justfile
```
### Environment Issues
```bash
# Verify environment files exist
ls -la .env api/.env dashboard/.env.local
# Run setup to create missing files
just setup
```
### Docker Issues
```bash
# Clean Docker environment
just clean
# Restart Docker service
sudo systemctl restart docker # Linux
```
## Custom Commands and Extensions
You can extend the `justfile` with your own commands. Add to the bottom of the file:
```bash
# Custom command example
my-command:
@echo "Running my custom command"
# Your commands here
# Command with parameters
deploy env:
@echo "Deploying to {{env}}"
# Deployment commands
```
Use custom commands:
```bash
just my-command
just deploy staging
```
## Best Practices
### Daily Development
1. `just api-native` for API development (fastest)
2. `just fe-run` for frontend development
3. `just lint && just test` before commits
### Integration Testing
1. `just up` for full environment
2. `just logs` for monitoring
3. `just clean` when issues arise
### Production Preparation
1. `just api-build && just fe-build` for production builds
2. `just test` for validation
3. `just up` for final testing
## Related Documentation
- [Backend Setup Guide](/v2/self-hosting/backend-setup) - Complete setup instructions
- [Docker Guide](/v2/self-hosting/docker-guide) - Docker-specific commands
- [Development Workflow](/v2/self-hosting/development) - Development best practices