Neurosymbolic Engines Supported by SymbolicAI: Complete Provider Guide

SymbolicAI supports over 15 neurosymbolic engines spanning OpenAI GPT-4/5, Anthropic Claude, Google Gemini, DeepSeek, Groq, OpenRouter, and local inference via LLaMA-cpp and HuggingFace transformers, all unified under a common Engine interface in symai/backend/engines/neurosymbolic/.

SymbolicAI (extensityai/symbolicai) is a neurosymbolic programming framework that abstracts large language model interactions through a modular backend architecture. The framework's neurosymbolic engines handle token counting, request payload construction, and response post-processing, enabling seamless provider switching without code changes.

Overview of SymbolicAI Neurosymbolic Engine Architecture

All neurosymbolic engines in SymbolicAI inherit from the core Engine class and implement a standardized contract exposing forward(), prepare(), and token-budget helpers (compute_required_tokens, compute_remaining_tokens). This uniform interface allows high-level Symbol and Function abstractions to route requests through any registered backend via configuration alone.

Engines reside in the symai/backend/engines/neurosymbolic/ directory, with each provider implemented as a separate module handling provider-specific authentication, payload formatting, and response parsing.

Supported Neurosymbolic Engine Providers

SymbolicAI ships with dedicated engine implementations for major cloud providers, aggregation services, and local inference options.

OpenAI GPT-X Series

The OpenAI integration splits into chat-optimized and reasoning-optimized variants:

• engine_openai_gptX_chat.py: Handles GPT-4/5 chat models with full support for vision inputs, function calling, and self-prompting capabilities.
• engine_openai_gptX_reasoning.py: Optimized for reasoning tasks with token-aware truncation and extended context handling.
• engine_openai_responses.py: Simple completion-style interface for older text-davinci-style endpoints.

Anthropic Claude

Direct Anthropic API integration supporting both conversational and analytical modes:

• engine_anthropic_claudeX_chat.py: Chat-optimized Claude engine with streaming and tool-call handling.
• engine_anthropic_claudeX_reasoning.py: Pure reasoning mode for complex analytical workflows.

Google Gemini

• engine_google_geminiX_reasoning.py: Gemini-1.5-pro style reasoning with built-in token-budget enforcement and Google AI Studio integration.

DeepSeek

• engine_deepseekX_reasoning.py: DeepSeek Chat model support with special handling for image-vision patterns and bilingual optimization.

Aggregation and Specialized Providers

OpenRouter (engine_openrouter.py): Proxy-compatible engine supporting any model hosted on OpenRouter (Mixtral, Claude-via-OpenRouter, etc.). Handles API-key injection, model-name prefix stripping, and optional "thinking" tag extraction.

Groq (engine_groq.py): Low-latency inference on Groq's hosted Llama-3 and Claude-like models, utilizing the same token-management utilities as OpenAI engines.

Cerebras (engine_cerebras.py): Direct integration with Cerebras' LLM service, exposing unique token-counting logic for their hardware-optimized inference.

Local Inference Engines

LLaMA-cpp (engine_llama_cpp.py): Runs a locally compiled LLaMA-cpp binary for entirely offline inference. Requires the binary on PATH and a local model file.

HuggingFace Transformers (engine_huggingface.py): Wraps any HuggingFace AutoModelForCausalLM pipeline, supporting optional quantization and custom model loading for self-hosted deployments.

Configuring and Using Neurosymbolic Engines

SymbolicAI uses a configuration-driven approach to engine selection, allowing runtime provider switching without code modification.

Selecting an Engine via Configuration

import symai as sy

# Load the default config (searches ~/.symai/, CWD, etc.)

config = sy.config_manager()

# Configure OpenAI GPT-4o-mini as the neurosymbolic engine

config["NEUROSYMBOLIC_ENGINE_MODEL"] = "gpt-4o-mini"
config["NEUROSYMBOLIC_ENGINE_API_KEY"] = "sk-..."

# The EngineRepository registers this automatically on import

# All subsequent SymbolicAI operations use the configured engine

Using Functions with Specific Engines

Override the default engine for individual function calls:

from symai import Function, zero_shot

@zero_shot(prompt="Solve the equation: {{ equation }}")
def solve(equation: str) -> str:
    ...

# Route through OpenRouter with specific model

result, meta = solve(
    equation="x**2 - 5*x + 6 = 0",
    engine="openrouter",
    model="openrouter:meta-llama/Meta-Llama-3.1-70B-Instruct",
    api_key="or-..."
)

print(result)           # LLM-generated solution

print(meta["thinking"]) # Optional extracted reasoning block

Running Local LLaMA-cpp Offline

# Ensure llama.cpp binary is on PATH and model file exists

config["NEUROSYMBOLIC_ENGINE_MODEL"] = "llama_cpp"
config["NEUROSYMBOLIC_ENGINE_API_KEY"] = ""  # Not required for local inference

from symai import Function, zero_shot

@zero_shot(prompt="Summarize:\n{{ text }}")
def summarize(text: str) -> str:
    ...

summary, _ = summarize(
    text="Quantum computing promises exponential speed-ups...",
    engine="llama_cpp"
)
print(summary)

Key Implementation Files

File	Role
symai/backend/engines/neurosymbolic/__init__.py	Package initialization and convenience exports
engine_openai_gptX_chat.py	OpenAI GPT-4/5 chat models with vision and function calling
engine_openai_gptX_reasoning.py	OpenAI reasoning-optimized engine with token truncation
engine_openai_responses.py	Legacy OpenAI completion endpoint wrapper
engine_openrouter.py	OpenRouter proxy for multi-provider access
engine_groq.py	Groq low-latency inference engine
engine_anthropic_claudeX_chat.py	Anthropic Claude conversational mode
engine_anthropic_claudeX_reasoning.py	Anthropic Claude analytical reasoning
engine_google_geminiX_reasoning.py	Google Gemini reasoning with token budgets
engine_deepseekX_reasoning.py	DeepSeek model support
engine_cerebras.py	Cerebras hardware-optimized inference
engine_llama_cpp.py	Local LLaMA-cpp binary execution
engine_huggingface.py	HuggingFace transformers pipeline wrapper

Summary

• SymbolicAI supports 15+ neurosymbolic engines spanning commercial APIs, aggregation services, and local inference options.
• All engines inherit from a common Engine base class in symai/backend/engines/neurosymbolic/, providing uniform forward(), prepare(), and token-management methods.
• Configuration-driven selection allows runtime switching between OpenAI, Anthropic, Google, DeepSeek, Groq, OpenRouter, Cerebras, and local LLaMA-cpp or HuggingFace models without code changes.
• Specialized implementations handle provider-specific features like OpenAI function calling, Anthropic tool use, OpenRouter model prefix stripping, and LLaMA-cpp offline execution.

Frequently Asked Questions

How do I switch between neurosymbolic engines in SymbolicAI?

Use the config_manager() to set NEUROSYMBOLIC_ENGINE_MODEL and NEUROSYMBOLIC_ENGINE_API_KEY. The EngineRepository automatically registers the selected engine on import, routing all subsequent Symbol and Function calls through the new provider without requiring code modifications.

Can I use multiple neurosymbolic engines in the same SymbolicAI application?

Yes. While the configuration sets a default engine, you can override the engine for individual function calls by passing engine, model, and api_key parameters directly to the Function or Symbol method. This enables routing specific tasks to specialized providers, such as using Groq for low-latency calls and OpenAI for complex reasoning.

What is the difference between chat and reasoning engine variants in SymbolicAI?

Chat-optimized engines (e.g., engine_openai_gptX_chat.py, engine_anthropic_claudeX_chat.py) are tuned for conversational interactions, supporting features like vision inputs, function calling, and streaming responses. Reasoning-optimized engines (e.g., engine_openai_gptX_reasoning.py, engine_anthropic_claudeX_reasoning.py) focus on analytical tasks with enhanced token-budget enforcement, truncation logic, and extended context handling for complex problem-solving workflows.

How do I run SymbolicAI with a local model using LLaMA-cpp?

Set NEUROSYMBOLIC_ENGINE_MODEL to "llama_cpp" and ensure the llama.cpp binary is available on your system PATH with a local model file. No API key is required. Import symai and use Function or zero_shot decorators normally; the engine routes requests to your local binary for fully offline inference.

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