Overview

from kapso.kapso import Kapso, DeployStrategy

kapso = Kapso()
solution = kapso.evolve(goal="Build a classifier")

# Deploy with explicit strategy
deployed_program = kapso.deploy(solution, strategy=DeployStrategy.LOCAL)

# Run inference
result = deployed_program.run({"data_path": "./test.csv"})
print(result)  # {"status": "success", "output": ...}

# Lifecycle management
deployed_program.stop()
deployed_program.start()
deployed_program.stop()

from kapso.deployment import DeployStrategy

DeployStrategy.AUTO      # System selects
DeployStrategy.LOCAL     # Local process
DeployStrategy.DOCKER    # Docker container
DeployStrategy.MODAL     # Modal.com
DeployStrategy.BENTOML   # BentoML
DeployStrategy.LANGGRAPH # LangGraph

class Software:
    def run(self, inputs: Dict) -> Dict:
        """Execute with input data."""
        # Returns: {"status": "success", "output": ...}
        # Or: {"status": "error", "error": ...}

    def stop(self) -> None:
        """Stop and cleanup resources."""

    def start(self) -> None:
        """Restart a stopped deployment."""

    def is_healthy(self) -> bool:
        """Check if service is running."""

    def logs(self) -> str:
        """Get execution logs."""

# Success
{"status": "success", "output": <result>}

# Error
{"status": "error", "error": <message>}

from kapso.deployment import DeployConfig

config = DeployConfig(
    solution=solution,
    env_vars={"API_KEY": "..."},
    coding_agent="claude_code",
)

deployed_program = DeploymentFactory.create(DeployStrategy.LOCAL, config)

# Get deployment metadata
info = deployed_program.get_deployment_info()
print(info)
# {
#     "strategy": "local",
#     "provider": None,
#     "endpoint": None,
#     "adapted_path": "/path/to/adapted",
#     "adapted_files": ["main.py", "run.py"],
#     "resources": {}
# }

# Individual accessors
deployed_program.get_strategy()      # "local"
deployed_program.get_adapted_path()  # Path to adapted code
deployed_program.get_endpoint()      # HTTP endpoint (if applicable)

deployed_program = kapso.deploy(solution, strategy=DeployStrategy.LOCAL)

# Initial run
result = deployed_program.run({"data": "..."})

# Check health
if deployed_program.is_healthy():
    print("Service is running")

# Stop (cleanup resources)
deployed_program.stop()

# Restart
deployed_program.start()

# Run again
result = deployed_program.run({"data": "..."})

# Final cleanup
deployed_program.stop()

result = deployed_program.run({"data": "..."})

if result["status"] == "error":
    print(f"Error: {result['error']}")
    print(f"Logs: {deployed_program.logs()}")