# Neurosymbolic Engines Supported by SymbolicAI: Complete Provider Guide

> Discover the 15+ neurosymbolic engines supported by SymbolicAI including GPT-4/5 Claude Gemini Groq and local LLMs. Streamline your AI development with our unified interface.

- Repository: [ExtensityAI/symbolicai](https://github.com/extensityai/symbolicai)
- Tags: how-to-guide
- Published: 2026-03-01

---

**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`](https://github.com/extensityai/symbolicai/blob/main/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`](https://github.com/extensityai/symbolicai/blob/main/engine_openai_gptX_reasoning.py)**: Optimized for reasoning tasks with token-aware truncation and extended context handling.
- **[`engine_openai_responses.py`](https://github.com/extensityai/symbolicai/blob/main/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`](https://github.com/extensityai/symbolicai/blob/main/engine_anthropic_claudeX_chat.py)**: Chat-optimized Claude engine with streaming and tool-call handling.
- **[`engine_anthropic_claudeX_reasoning.py`](https://github.com/extensityai/symbolicai/blob/main/engine_anthropic_claudeX_reasoning.py)**: Pure reasoning mode for complex analytical workflows.

### Google Gemini

- **[`engine_google_geminiX_reasoning.py`](https://github.com/extensityai/symbolicai/blob/main/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`](https://github.com/extensityai/symbolicai/blob/main/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`](https://github.com/extensityai/symbolicai/blob/main/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`](https://github.com/extensityai/symbolicai/blob/main/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`](https://github.com/extensityai/symbolicai/blob/main/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`](https://github.com/extensityai/symbolicai/blob/main/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`](https://github.com/extensityai/symbolicai/blob/main/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

```python
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:

```python
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

```python

# 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`](https://github.com/extensityai/symbolicai/blob/main/symai/backend/engines/neurosymbolic/__init__.py) | Package initialization and convenience exports |
| [`engine_openai_gptX_chat.py`](https://github.com/extensityai/symbolicai/blob/main/engine_openai_gptX_chat.py) | OpenAI GPT-4/5 chat models with vision and function calling |
| [`engine_openai_gptX_reasoning.py`](https://github.com/extensityai/symbolicai/blob/main/engine_openai_gptX_reasoning.py) | OpenAI reasoning-optimized engine with token truncation |
| [`engine_openai_responses.py`](https://github.com/extensityai/symbolicai/blob/main/engine_openai_responses.py) | Legacy OpenAI completion endpoint wrapper |
| [`engine_openrouter.py`](https://github.com/extensityai/symbolicai/blob/main/engine_openrouter.py) | OpenRouter proxy for multi-provider access |
| [`engine_groq.py`](https://github.com/extensityai/symbolicai/blob/main/engine_groq.py) | Groq low-latency inference engine |
| [`engine_anthropic_claudeX_chat.py`](https://github.com/extensityai/symbolicai/blob/main/engine_anthropic_claudeX_chat.py) | Anthropic Claude conversational mode |
| [`engine_anthropic_claudeX_reasoning.py`](https://github.com/extensityai/symbolicai/blob/main/engine_anthropic_claudeX_reasoning.py) | Anthropic Claude analytical reasoning |
| [`engine_google_geminiX_reasoning.py`](https://github.com/extensityai/symbolicai/blob/main/engine_google_geminiX_reasoning.py) | Google Gemini reasoning with token budgets |
| [`engine_deepseekX_reasoning.py`](https://github.com/extensityai/symbolicai/blob/main/engine_deepseekX_reasoning.py) | DeepSeek model support |
| [`engine_cerebras.py`](https://github.com/extensityai/symbolicai/blob/main/engine_cerebras.py) | Cerebras hardware-optimized inference |
| [`engine_llama_cpp.py`](https://github.com/extensityai/symbolicai/blob/main/engine_llama_cpp.py) | Local LLaMA-cpp binary execution |
| [`engine_huggingface.py`](https://github.com/extensityai/symbolicai/blob/main/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`](https://github.com/extensityai/symbolicai/blob/main/engine_openai_gptX_chat.py), [`engine_anthropic_claudeX_chat.py`](https://github.com/extensityai/symbolicai/blob/main/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`](https://github.com/extensityai/symbolicai/blob/main/engine_openai_gptX_reasoning.py), [`engine_anthropic_claudeX_reasoning.py`](https://github.com/extensityai/symbolicai/blob/main/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`](https://github.com/extensityai/symbolicai/blob/main/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.