SymbolicAI CLI Entry Points: A Complete Guide to Command-Line Tools

SymbolicAI provides seven CLI entry points—symchat, symsh, sympkg, symdev, symrun, symconfig, and symserver—defined in pyproject.toml that expose interactive chat, shell translation, package management, and server deployment functionality.

The ExtensityAI/symbolicai repository ships with a comprehensive set of command-line interfaces that expose high-level neuro-symbolic functionality without requiring Python imports. These SymbolicAI CLI entry points are registered during installation via the [project.scripts] section in pyproject.toml, creating executable wrappers that map short commands to specific Python callables across the codebase.

How SymbolicAI CLI Entry Points Are Configured

In pyproject.toml at the repository root, the [project.scripts] table maps command names to Python callables using the module:callable syntax. When you run pip install symbolicai, the Python packaging machinery generates platform-specific executables that invoke these functions.

The available SymbolicAI CLI entry points and their mappings are:

• symchat: symai.chat:run
• symsh: symai.shell:run
• sympkg: symai.extended.packages.sympkg:run
• symdev: symai.extended.packages.symdev:run
• symrun: symai.extended.packages.symrun:run
• symconfig: symai:display_config
• symserver: symai:run_server

Each callable acts as a thin wrapper that initializes the environment—loading configurations and preparing the engine repository—before delegating to the core implementation.

Complete Reference for SymbolicAI CLI Commands

symchat - Interactive Neuro-Symbolic Chat

The symchat command launches an interactive REPL-like chat session backed by large language models. Implemented in symai/chat.py, the entry function run() instantiates a SymbiaChat object and enters a conversation loop.

symchat

symsh - Natural Language to Shell Translation

symsh converts natural language descriptions into executable shell commands. Located in symai/shell.py, this tool parses your query, constructs a Shell expression, and uses zero-shot LLM prompting to generate commands ending with EOF.

symsh "list all python files recursively"

Add --exec to execute the generated command automatically rather than printing it.

sympkg - Extension Package Manager

The sympkg command manages SymbolicAI extensions through sub-commands (i for install, r for remove, l for list, u for update, U for upgrade). Defined in symai/extended/packages/sympkg.py, it forwards operations to the Import utility via PackageHandler.i().

sympkg i myorg/myextension --submodules

symdev - Package Development Scaffolding

symdev bootstraps new GitHub-hosted SymbolicAI packages. The implementation in symai/extended/packages/symdev.py creates directory structures in ~/.symai/packages/ with README, package.json, and starter func.py files containing a customizable MyExpression class.

symdev c alice/awesome-tool

symrun - Execute Package Expressions

Use symrun to load and execute user-defined expressions from installed packages. The entry point in symai/extended/packages/symrun.py loads the specified class and executes it with a JSON payload.

symrun alice/awesome-tool src/func MyExpression '{"input": "hello"}'

symconfig - Configuration Inspection

symconfig prints the current SymbolicAI configuration state, including paths, engine settings, and overrides from symai.config.json. The callable display_config resides in symai/__init__.py and outputs the ConfigManager state.

symconfig

symserver - FastAPI Server Deployment

The symserver command starts a built-in FastAPI server for serving SymbolicAI services such as vector search and embeddings. The entry point run_server in symai/__init__.py delegates to the server implementation in symai/server.py.

symserver --host 0.0.0.0 --port 8000

Implementation Details and Source Mapping

Each CLI entry point follows a consistent architectural pattern: the wrapper function sets up the execution environment before invoking domain-specific logic.

• symchat → symai/chat.py creates a SymbiaChat instance and runs its main loop
• symsh → symai/shell.py builds Shell expressions and handles command generation
• sympkg → symai/extended/packages/sympkg.py parses sub-commands and manages packages via the Import utility
• symdev → symai/extended/packages/symdev.py scaffolds directories with starter templates
• symrun → symai/extended/packages/symrun.py dynamically loads and executes package classes
• symconfig → symai/__init__.py exposes configuration via display_config
• symserver → symai/server.py boots the FastAPI application through run_server

Summary

• Seven CLI entry points are defined in pyproject.toml under [project.scripts]: symchat, symsh, sympkg, symdev, symrun, symconfig, and symserver
• symchat and symsh provide interactive AI interfaces for conversation and shell command generation implemented in symai/chat.py and symai/shell.py
• sympkg, symdev, and symrun form a complete package management ecosystem in symai/extended/packages/ for installing, creating, and executing extensions
• symconfig and symserver handle operational concerns like configuration inspection and API deployment through callables exposed in symai/__init__.py
• All entry points act as thin environment-setup wrappers before delegating to core implementations in their respective modules

Frequently Asked Questions

Where are SymbolicAI CLI entry points defined?

The entry points are declared in the pyproject.toml file at the repository root within the [project.scripts] section. This standard Python packaging configuration tells pip to create executable wrappers that map commands like symchat to Python callables such as symai.chat:run, making them available in your system PATH immediately after installation.

How does symsh execute generated shell commands?

By default, symsh prints the generated shell command without executing it to prevent accidental operations. To run the command automatically, append the --exec flag to your invocation. The tool uses zero-shot LLM prompting implemented in symai/shell.py to translate natural language into shell syntax ending with EOF markers.

What is the difference between symdev and symrun?

symdev creates a new package skeleton for development purposes, scaffolding directories and starter files in ~/.symai/packages/ with a func.py containing a MyExpression class template. In contrast, symrun executes existing expressions from installed packages by loading the specified class from src/func and passing JSON arguments to it.

Can I customize the host and port for symserver?

Yes, the symserver command accepts standard FastAPI server arguments including --host and --port. The entry point symai:run_server defined in pyproject.toml invokes the server implementation in symai/server.py, which processes these arguments to configure the ASGI application binding.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}