SymbolicAI

https://extensityai.gitbook.io/symbolicai
Admin
SymbolicAI is a neuro-symbolic framework that leverages LLMs to bridge classical and data-driven...
Tokens:43,934
Snippets:265
Trust Score:10
Update:1 year ago
Show doc for...
Tokens:
Raw
### Examples for Installing Packages with sympkg

Source: https://extensityai.gitbook.io/symbolicai/tools/packages

Provides practical examples of installing packages using `sympkg`, showcasing how to install from a GitHub repository with submodules and from a local file path. These examples illustrate the `--submodules` and `--local-path` options.

```Shell
sympkg i ExtensityAI/symask --submodules
```

```Shell
sympkg i ExtensityAI/symask /path/to/local/package
```

--------------------------------

### Example symai.config.json with Enabled Engines

Source: https://extensityai.gitbook.io/symbolicai/installation

This JSON snippet provides an example of a `symai.config.json` file with various SymbolicAI engines configured. It demonstrates how to set API keys and models for neurosymbolic, symbolic, embedding, drawing, vision, search, OCR, speech-to-text, text-to-speech, and indexing engines.

```json
{
    "NEUROSYMBOLIC_ENGINE_API_KEY": "<OPENAI_API_KEY>",
    "NEUROSYMBOLIC_ENGINE_MODEL": "gpt-4o",
    "SYMBOLIC_ENGINE_API_KEY": "<WOLFRAMALPHA_API_KEY>",
    "SYMBOLIC_ENGINE": "wolframalpha",
    "EMBEDDING_ENGINE_API_KEY": "<OPENAI_API_KEY>",
    "EMBEDDING_ENGINE_MODEL": "text-embedding-3-small",
    "DRAWING_ENGINE_API_KEY": "<OPENAI_API_KEY>",
    "DRAWING_ENGINE_MODEL": "dall-e-3",
    "VISION_ENGINE_MODEL": "openai/clip-vit-base-patch32",
    "SEARCH_ENGINE_API_KEY": "<PERPLEXITY_API_KEY>",
    "SEARCH_ENGINE_MODEL": "llama-3.1-sonar-small-128k-online",
    "OCR_ENGINE_API_KEY": "<APILAYER_API_KEY>",
    "SPEECH_TO_TEXT_ENGINE_MODEL": "turbo",
    "TEXT_TO_SPEECH_ENGINE_MODEL": "tts-1",
    "INDEXING_ENGINE_API_KEY": "<PINECONE_API_KEY>",
    "INDEXING_ENGINE_ENVIRONMENT": "us-west1-gcp",
    "COLLECTION_DB": "ExtensityAI",
    "COLLECTION_STORAGE": "SymbolicAI",
    "SUPPORT_COMMUNITY": true
}
```

--------------------------------

### Install SymbolicAI Core Library

Source: https://extensityai.gitbook.io/symbolicai/installation

Install the core SymbolicAI library using pip. This provides the fundamental functionalities of the framework.

```Python
pip install symbolicai
```

--------------------------------

### Install All Optional SymbolicAI Dependencies

Source: https://extensityai.gitbook.io/symbolicai/installation

Install all optional SymbolicAI dependencies at once using pip. This provides access to all extended features, including WolframAlpha, Whisper, Selenium, SerpAPI, and Pinecone.

```Python
pip install "symbolicai[all]"
```

--------------------------------

### View SymbolicAI Configuration with symconfig CLI

Source: https://extensityai.gitbook.io/symbolicai/installation

This command allows users to inspect their current SymbolicAI configuration setup. It displays all configuration locations, active paths, and current settings (with sensitive data truncated), and creates necessary configuration files if they do not already exist.

```Shell
symconfig
```

--------------------------------

### Install Optional SymbolicAI Dependencies Individually

Source: https://extensityai.gitbook.io/symbolicai/installation

Install specific optional SymbolicAI dependencies using pip to enable features like WolframAlpha integration, Whisper for speech, Selenium for web crawling, and SerpAPI for search. Choose only the features you need.

```Python
pip install "symbolicai[wolframalpha]"
pip install "symbolicai[whisper]"
pip install "symbolicai[selenium]"
pip install "symbolicai[serpapi]"
pip install "symbolicai[pinecone]"
```

--------------------------------

### Create and Translate SymbolicAI Symbols

Source: https://extensityai.gitbook.io/symbolicai/quickstart

This example shows how to create a `Symbol` object with a string and then use its `translate` method to convert its content to another language. The `Symbol` class is the base for all functional operations in SymbolicAI.

```Python
# Create a Symbol
S = Symbol("Welcome to our tutorial.")
# Translate the Symbol
print(S.translate('German')) # Output: Willkommen zu unserem Tutorial.
```

--------------------------------

### Download HuggingFace Model with HuggingFace CLI

Source: https://extensityai.gitbook.io/symbolicai/engines/local_engine

Downloads the `dolphin-2.9.3-mistral-7B-32k` model from HuggingFace, saving it to a local directory. This model is used as an example for setting up the HuggingFace backend.

```Shell
huggingface-cli download cognitivecomputations/dolphin-2.9.3-mistral-7B-32k --local-dir ./dolphin-2.9.3-mistral-7B-32k
```

--------------------------------

### Import SymbolicAI Library

Source: https://extensityai.gitbook.io/symbolicai/quickstart

This snippet demonstrates how to import the `Symbol` class from the `symai` library, which is the foundational step for using SymbolicAI's functional operations.

```Python
from symai import Symbol
```

--------------------------------

### Understand SymbolicAI Configuration Priority Hierarchy

Source: https://extensityai.gitbook.io/symbolicai/installation

This example illustrates the priority order for SymbolicAI configuration files across different locations: debug mode (current directory), environment-specific, and global home directory. The system uses the highest-priority version if configuration files exist in multiple locations, falling back to lower priorities if higher ones are missing or invalid.

```Text
my_project/              # Debug mode (highest priority)
└── symai.config.json    # Only this file is checked in debug mode

{python_env}/.symai/     # Environment config (second priority)
├── symai.config.json
├── symsh.config.json
└── symserver.config.json

~/.symai/                # Global config (lowest priority)
├── symai.config.json
├── symsh.config.json
└── symserver.config.json
```

--------------------------------

### Install FFmpeg for SpeechToText Engine (Linux)

Source: https://extensityai.gitbook.io/symbolicai/installation

Install the `ffmpeg` library on Linux using `apt` for audio processing required by the SpeechToText engine (based on OpenAI's Whisper). This is a prerequisite for audio transcription features.

```Shell
sudo apt update && sudo apt install ffmpeg
```

--------------------------------

### Install FFmpeg for SpeechToText Engine (Windows)

Source: https://extensityai.gitbook.io/symbolicai/installation

Install the `ffmpeg` library on Windows using `choco` for audio processing required by the SpeechToText engine (based on OpenAI's Whisper). This is necessary for audio transcription.

```Shell
choco install ffmpeg
```

--------------------------------

### Start Symserver for Embeddings with C++ Server

Source: https://extensityai.gitbook.io/symbolicai/engines/local_engine

This command starts the `symserver` utilizing the C++ backend, tailored for efficient embedding operations. It specifies the path to the `llama.cpp` server, loads the Nomic embed model, enables embedding, and sets advanced parameters like context size, batch size, and rope scaling for optimal performance.

```Bash
symserver --env cpp --cpp-server-path /path/to/llama.cpp/server  -ngl 0 -m nomic-embed-text-v1.5.Q8_0.gguf --embedding -c 8192 -b 8192 --rope-scaling yarn --rope-freq-scale .75 --port 8000 --host localhost
```

--------------------------------

### Run symserver with llama.cpp C++ Server

Source: https://extensityai.gitbook.io/symbolicai/engines/local_engine

Starts the `symai` server directly using the `llama.cpp` C++ server executable, providing the model path, port, and host. This offers an alternative, potentially more performant, way to run the local engine.

```Shell
symserver --env cpp --cpp-server-path /path/to/llama.cpp/server -m ./llama-pro-8b-instruct.Q4_K_M.gguf --port 8000 --host localhost
```

--------------------------------

### Start Symserver for Embeddings with Python Bindings

Source: https://extensityai.gitbook.io/symbolicai/engines/local_engine

This command initializes the `symserver` using its Python bindings, specifically configured for embedding generation. It loads the `nomic-embed-text-v1.5.Q8_0.gguf` model, enables embedding mode, and optimizes performance with context size, rope scaling, and batching parameters.

```Bash
symserver --env python --model nomic-embed-text-v1.5.Q8_0.gguf --embedding True --n_ctx 2048 --rope_scaling_type 2 --rope_freq_scale 0.75 --n_batch 32 --port 8000 --host localhost
```

--------------------------------

### Run symserver with llama.cpp Python Bindings

Source: https://extensityai.gitbook.io/symbolicai/engines/local_engine

Starts the `symai` server using `llama-cpp-python` bindings, specifying the model path, GPU layers, chat format, port, and host. This enables local inference with `llama.cpp` via Python.

```Shell
symserver --env python --model ./llama-pro-8b-instruct.Q4_K_M.gguf --n_gpu_layers -1 --chat_format llama-3 --port 8000 --host localhost
```

--------------------------------

### Run symserver with HuggingFace Backend

Source: https://extensityai.gitbook.io/symbolicai/engines/local_engine

Starts the `symai` server using a locally downloaded HuggingFace model, enabling specific attention implementations like `flash_attention_2`. This allows `symai` to leverage HuggingFace models for local inference.

```Shell
symserver --model ./dolphin-2.9.3-mistral-7B-32k --attn_implementation flash_attention_2
```

--------------------------------

### Install FFmpeg for SpeechToText Engine (MacOS)

Source: https://extensityai.gitbook.io/symbolicai/installation

Install the `ffmpeg` library on MacOS using `brew` for audio processing required by the SpeechToText engine (based on OpenAI's Whisper). This enables audio transcription functionalities.

```Shell
brew install ffmpeg
```

--------------------------------

### Rank Numerical Data with SymbolicAI

Source: https://extensityai.gitbook.io/symbolicai/quickstart

This snippet illustrates how to use the SymbolicAI API to rank a list of numbers. It demonstrates a data-agnostic operation, utilizing `numpy` arrays and the `rank` method with specified measure and order parameters.

```Python
# Ranking objects
import numpy as np

S = Symbol(np.array([1, 2, 3, 4, 5, 6, 7]))
print(S.rank(measure='numerical', order='descending')) # Output: ['7', '6', '5', '4', '3', '2', '1']
```

--------------------------------

### Set Neuro-Symbolic Engine API Keys (Jupyter Notebooks)

Source: https://extensityai.gitbook.io/symbolicai/installation

Configure the API key and model for neuro-symbolic engines within a Jupyter Notebook environment using the %env magic command. This is useful for interactive development.

```Python
%env NEUROSYMBOLIC_ENGINE_API_KEY=…
%env NEUROSYMBOLIC_ENGINE_MODEL=…
```

--------------------------------

### Download Llama 3 Model with HuggingFace CLI

Source: https://extensityai.gitbook.io/symbolicai/engines/local_engine

Downloads the Llama 3 model (`llama-pro-8b-instruct.Q4_K_M.gguf`) using the HuggingFace CLI, saving it to the current directory. This is a prerequisite for setting up the `llama.cpp` backend.

```Shell
huggingface-cli download TheBloke/LLaMA-Pro-8B-Instruct-GGUF llama-pro-8b-instruct.Q4_K_M.gguf --local-dir .
```

--------------------------------

### Default symai.config.json Structure

Source: https://extensityai.gitbook.io/symbolicai/installation

This JSON snippet illustrates the default structure of the `symai.config.json` file, which is automatically generated. It outlines all configurable engine properties and settings available for SymbolicAI.

```json
{
    "NEUROSYMBOLIC_ENGINE_API_KEY": "",
    "NEUROSYMBOLIC_ENGINE_MODEL": "",
    "SYMBOLIC_ENGINE_API_KEY": "",
    "SYMBOLIC_ENGINE": "",
    "EMBEDDING_ENGINE_API_KEY": "",
    "EMBEDDING_ENGINE_MODEL": "",
    "DRAWING_ENGINE_MODEL": "",
    "DRAWING_ENGINE_API_KEY": "",
    "SEARCH_ENGINE_API_KEY": "",
    "SEARCH_ENGINE_MODEL": "",
    "INDEXING_ENGINE_API_KEY": "",
    "INDEXING_ENGINE_ENVIRONMENT": "",
    "TEXT_TO_SPEECH_ENGINE_MODEL": "",
    "TEXT_TO_SPEECH_ENGINE_API_KEY": "",
    "SPEECH_TO_TEXT_ENGINE_MODEL": "",
    "VISION_ENGINE_MODEL": "",
    "OCR_ENGINE_API_KEY": "",
    "COLLECTION_URI": "",
    "COLLECTION_DB": "",
    "COLLECTION_STORAGE": "",
    "SUPPORT_COMMUNITY": false
}
```

--------------------------------

### Python: Install Packages Using Import.install

Source: https://extensityai.gitbook.io/symbolicai/features/import

This snippet showcases the `Import.install` method for installing packages without immediate instantiation. It covers basic installation, installation with Git submodules, and installing a local directory as a named package. The method handles repository cloning and dependency installation.

```Python
# Basic installation
Import.install("ExtensityAI/symask")

# Install with Git submodules
Import.install("ExtensityAI/symask", submodules=True)

# Install from a local directory
Import.install("username/repo_name", local_path="/path/to/local/module")
```

--------------------------------

### Perform Causal Reasoning with Logical Implication (Python)

Source: https://extensityai.gitbook.io/symbolicai/quickstart

This example showcases SymbolicAI's causal reasoning capabilities, enabling deductive reasoning on top of Language Models. It demonstrates how the '&' operator is overloaded to compute the logical implication between two symbols, defining causal relationships.

```Python
S1 = Symbol('The horn only sounds on Sundays.', semantic=True)
S2 = Symbol('I hear the horn.')
res = S1 & S2 # Therefore, it is Sunday.
```

--------------------------------

### Access Help for sympkg Commands

Source: https://extensityai.gitbook.io/symbolicai/tools/packages

Demonstrates how to use the `--help` flag with `sympkg` commands to get detailed usage information and available options. This is useful for understanding specific command functionalities.

```Shell
sympkg i --help
```

--------------------------------

### Export Optional Engine API Keys (Windows PowerShell)

Source: https://extensityai.gitbook.io/symbolicai/installation

Set environment variables for various optional engine API keys on Windows using PowerShell, including WolframAlpha, SerpAPI, APILayer, and Pinecone. These configurations enable extended SymbolicAI features.

```PowerShell
$Env:SYMBOLIC_ENGINE_API_KEY="<WOLFRAMALPHA_API_KEY>"
$Env:SEARCH_ENGINE_API_KEY="<SERP_API_KEY>"
$Env:OCR_ENGINE_API_KEY="<APILAYER_API_KEY>"
$Env:INDEXING_ENGINE_API_KEY="<PINECONE_API_KEY>"
```

--------------------------------

### View General symserver Command Line Options

Source: https://extensityai.gitbook.io/symbolicai/engines/local_engine

Displays all available command-line options for the `symserver` utility. This provides comprehensive help for configuring the `symai` server, including options relevant to the HuggingFace backend.

```Shell
symserver --help
```

--------------------------------

### Set Neuro-Symbolic Engine API Keys (Windows PowerShell)

Source: https://extensityai.gitbook.io/symbolicai/installation

Configure the API key and model for neuro-symbolic engines like OpenAI or Anthropic on Windows using PowerShell. This allows SymbolicAI to authenticate with external AI services.

```PowerShell
$Env:NEUROSYMBOLIC_ENGINE_API_KEY="…"
$Env:NEUROSYMBOLIC_ENGINE_MODEL="…"
```

--------------------------------

### Export Optional Engine API Keys (Linux/MacOS)

Source: https://extensityai.gitbook.io/symbolicai/installation

Set environment variables for various optional engine API keys on Linux and MacOS, including WolframAlpha, SerpAPI, APILayer, and Pinecone. These keys are essential for enabling advanced functionalities.

```Shell
export SYMBOLIC_ENGINE_API_KEY="<WOLFRAMALPHA_API_KEY>"
export SEARCH_ENGINE_API_KEY="<SERP_API_KEY>"
export OCR_ENGINE_API_KEY="<APILAYER_API_KEY>"
export INDEXING_ENGINE_API_KEY="<PINECONE_API_KEY>"
```

--------------------------------

### Install New Packages with sympkg

Source: https://extensityai.gitbook.io/symbolicai/tools/packages

Details the `install` command (`i`) for `sympkg`, used to add new packages. It supports installation from GitHub repositories or local directories, with an option to initialize Git submodules.

```Shell
sympkg i <package> [--local-path PATH] [--submodules]
```

--------------------------------

### Set Neuro-Symbolic Engine API Keys (Linux/MacOS)

Source: https://extensityai.gitbook.io/symbolicai/installation

Configure the API key and model for neuro-symbolic engines like OpenAI or Anthropic on Linux and MacOS by exporting environment variables. This is crucial for accessing external AI services.

```Shell
export NEUROSYMBOLIC_ENGINE_API_KEY="…"
export NEUROSYMBOLIC_ENGINE_MODEL="…"
```

--------------------------------

### Perform Dynamic Casting for Sentence Manipulation (Python)

Source: https://extensityai.gitbook.io/symbolicai/quickstart

This example illustrates how SymbolicAI can subtract and add words to sentences, dynamically modifying them based on best-effort neural computation. It also highlights the API's ability to automatically cast other data types to a Symbol object when overloaded operations are used, simplifying syntax.

```Python
# Sentence manipulation
S = Symbol('Hello my enemy').sem - 'enemy' + 'friend'
print(S)  # Output: Hello my friend
```

--------------------------------

### Evaluate SymbolicAI Expressions for Word Analogy (Python)

Source: https://extensityai.gitbook.io/symbolicai/quickstart

This snippet demonstrates how SymbolicAI interprets natural language expressions to perform word analogies. It showcases operations in the language domain, allowing for human-readable verification of results, similar to word2vec but without operating in vector space.

```Python
# Word analogy
S = Symbol('King - Man + Women').interpret()
print(S)  # Output: Queen
```

--------------------------------

### Python Example: Sentiment Analyzer Setup

Source: https://extensityai.gitbook.io/symbolicai/features/contracts

Illustrates the basic setup for a sentiment analyzer using the `symai` library's `@contract` decorator, including necessary imports and Pydantic field definitions.

```Python
import logging
from typing import Optional, List
from pydantic import Field

from symai import Expression
# from symai.components import MetadataTracker # If you want to track LLM usage
from symai.models import LLMDataModel
from symai.strategy import contract

# Configure basic logging for visibility if running standalone
# In a larger application, logging might be configured globally.
# import logging # Make sure logging is imported at the top
# logging.basicConfig(level=logging.INFO)
```

--------------------------------

### Import SymbolicAI Libraries for Chatbot Development

Source: https://extensityai.gitbook.io/symbolicai/tutorials/chatbot

This snippet imports necessary modules from the SymbolicAI library, including core components and display utilities. It also handles environment setup by changing the working directory and suppressing warnings, preparing the environment for chatbot implementation.

```Python
import os
import warnings
warnings.filterwarnings('ignore')
os.chdir('../') # set the working directory to the root of the project
from symai import *
from symai.components import *
from IPython.display import display
```

--------------------------------

### View symserver Command Line Options for llama.cpp

Source: https://extensityai.gitbook.io/symbolicai/engines/local_engine

Displays all available command-line options for the `symserver` utility, specific to both Python bindings and the C++ server. This helps users understand and customize server behavior.

```Shell
symserver --env python --help  # for Python bindings
symserver --env cpp --cpp-server-path /path/to/llama.cpp/server --help  # for C++ server
```

--------------------------------

### Perform Symbolic Computation with Local Engine

Source: https://extensityai.gitbook.io/symbolicai/engines/local_engine

Demonstrates how to perform a simple symbolic computation using the `symai` library with the locally configured engine. It initializes a `Symbol` object and applies the `compose()` method to generate an output.

```Python
# do some symbolic computation with the local engine
sym = Symbol('Kitties are cute!').compose()
print(sym)

# :Output:
# Kittens are known for their adorable nature and fluffy appearance, making them a favorite addition to many homes across the world. They possess a strong bond with
```

--------------------------------

### Python: Indexing and Searching Text with Pinecone

Source: https://extensityai.gitbook.io/symbolicai/engines/indexing_engine

This Python example demonstrates how to use the SymbolicAI Indexing Engine with Pinecone to store and retrieve text. It shows how the `zip` method creates string and embedding vector pairs for indexing, and how the `get` method retrieves original sources based on vector values, casting the result to a dictionary.

```Python
expr = Expression()
expr.add(Symbol('Hello World!').zip())
expr.add(Symbol('I like cookies!').zip())
res = expr.get(Symbol('hello').embedding, index_name='default_index').ast()
res['matches'][0]['metadata']['text'][0]
```

--------------------------------

### Python: Import Packages with Advanced Options

Source: https://extensityai.gitbook.io/symbolicai/features/import

This snippet demonstrates various ways to import packages using the `Import` class, including initializing Git submodules, importing from a local directory, and installing a local path as a named package. These options provide fine-grained control over the import and installation process.

```Python
# Install a module with Git submodules initialized
symask_module = Import("ExtensityAI/symask", submodules=True)

# Import from a local directory
local_module = Import("/path/to/local/module")

# Import using a local path but install as a named package
named_local = Import("username/repo_name", local_path="/path/to/local/module")
```

--------------------------------

### Python: List All Installed Packages

Source: https://extensityai.gitbook.io/symbolicai/features/import

This snippet demonstrates how to retrieve a list of all packages currently installed on the system using the `Import.list_installed()` method. This provides an overview of available modules.

```Python
installed_packages = Import.list_installed()
```

--------------------------------

### Configure PerplexityAI Search Engine in JSON

Source: https://extensityai.gitbook.io/symbolicai/engines/search_engine

This JSON snippet provides an example configuration for setting up the PerplexityAI search engine. It includes the API key and the specific model to be used for queries, ensuring proper authentication and model selection.

```JSON
{
    …
    "SEARCH_ENGINE_API_KEY": "pplx-…",
    "SEARCH_ENGINE_MODEL": "llama-3.1-sonar-small-128k-online",
    …
}
```

--------------------------------

### Get Help for SymbolicAI Shell Tool

Source: https://extensityai.gitbook.io/symbolicai/tools/shell

To understand the available arguments and functionalities of the `symsh` command-line tool, use the `--help` flag. This provides detailed information on its usage and options.

```Shell
symsh --help
```

--------------------------------

### Example for Updating a Package with sympkg

Source: https://extensityai.gitbook.io/symbolicai/tools/packages

Illustrates how to update a specific package, including its Git submodules, using the `sympkg` command. This example highlights the use of the `--submodules` option during an update operation.

```Shell
sympkg u ExtensityAI/symask --submodules
```

--------------------------------

### Start SymbolicAI Shell with a Query

Source: https://extensityai.gitbook.io/symbolicai/tools/shell

This snippet demonstrates how to execute the `symsh` command-line tool by providing a natural language query directly. The tool will then attempt to translate the query into a relevant shell command.

```Shell
symsh "<your-query>"
```

--------------------------------

### Configure symai for llama.cpp Backend

Source: https://extensityai.gitbook.io/symbolicai/engines/local_engine

Sets the `NEUROSYMBOLIC_ENGINE_MODEL` environment variable to `llamacpp` in the `symai` configuration. This directs the Neuro-Symbolic Engine to use a local `llama.cpp` instance.

```JSON
{
  "NEUROSYMBOLIC_ENGINE_API_KEY": "",
  "NEUROSYMBOLIC_ENGINE_MODEL": "llamacpp",
  ...
}
```

--------------------------------

### Generate Text Embeddings with Symai Library

Source: https://extensityai.gitbook.io/symbolicai/engines/local_engine

This Python code demonstrates how to interact with the local embedding engine using the `symai` library. It provides examples for generating embeddings for a single text string and efficiently processing a batch of texts, showcasing the `Symbol().embed()` method's versatility.

```Python
from symai import Symbol

# Single text embedding
some_text = "Hello, world!"
embedding = Symbol(some_text).embed()  # returns a list (1 x dim)

# Batch processing
some_batch_of_texts = ["Hello, world!"] * 32
embeddings = Symbol(some_batch_of_texts).embed()  # returns a list (32 x dim)
```

--------------------------------

### Shell: Run Symbolic AI Alias with Git Submodules

Source: https://extensityai.gitbook.io/symbolicai/tools/packages

This command illustrates running a `symrun` alias while including the `--submodules` flag. This flag ensures that any necessary Git submodules are initialized and installed before the package execution, which is crucial for packages with external dependencies. It simplifies the setup process for complex packages.

```Shell
$> symrun my_alias arg1 arg2 --submodules
```

--------------------------------

### Download Nomic Embed Text Model for Local Use

Source: https://extensityai.gitbook.io/symbolicai/engines/local_engine

This `huggingface-cli` command downloads the `nomic-embed-text-v1.5.Q8_0.gguf` model, a quantized version suitable for `llama.cpp`. The `--local-dir .` flag ensures the model file is saved in the current directory, making it accessible for the local embedding server.

```Bash
huggingface-cli download nomic-ai/nomic-embed-text-v1.5-GGUF nomic-embed-text-v1.5.Q8_0.gguf --local-dir .
```

--------------------------------

### List All Installed Packages with sympkg

Source: https://extensityai.gitbook.io/symbolicai/tools/packages

Describes the `list` command (`l`) for `sympkg`, which displays all currently installed packages. This provides an overview of the extensions managed by the package manager.

```Shell
sympkg l
```

--------------------------------

### Instantiate and Run a SymbolicAI Chatbot

Source: https://extensityai.gitbook.io/symbolicai/tutorials/chatbot

This snippet demonstrates how to instantiate the `SymbiaChat` class and start the chatbot interaction. By calling the instance, the chatbot's `forward` method is invoked, initiating the conversational loop and allowing users to interact with the implemented AI.

```Python
from symai.chat import SymbiaChat

chat = SymbiaChat()
chat()
```

--------------------------------

### Python: Install Local Package with a Specific Name

Source: https://extensityai.gitbook.io/symbolicai/features/import

This snippet shows how to install a local package and register it under a specific name using `Import.install`. This allows the package to be referenced by its given name later, similar to a remote package, while still sourcing from a local directory. A `package.json` is required.

```Python
Import.install("username/repo_name", local_path="/path/to/local/module")
```

--------------------------------

### Configure symai for HuggingFace Backend

Source: https://extensityai.gitbook.io/symbolicai/engines/local_engine

Sets the `NEUROSYMBOLIC_ENGINE_MODEL` environment variable to `huggingface` in the `symai` configuration. This directs the Neuro-Symbolic Engine to use a local HuggingFace instance.

```JSON
{
  "NEUROSYMBOLIC_ENGINE_API_KEY": "",
  "NEUROSYMBOLIC_ENGINE_MODEL": "huggingface",
  ...
}
```

--------------------------------

### Translate SQL Query Explanation with SymbolicAI

Source: https://extensityai.gitbook.io/symbolicai/tutorials/data_query

This example illustrates how to translate the natural language explanation of an SQL query into a different language, such as German, using SymbolicAI's translation capabilities. It highlights the ease of localizing documentation or user feedback.

```Python
locale = Symbol(answer_doc).translate('German')
display(locale)
```

--------------------------------

### Demonstrate SymbolicAI Shell Command Capabilities

Source: https://extensityai.gitbook.io/symbolicai/tools/shell

This example showcases the versatility of the `symsh` tool, including translating natural language to PowerShell commands, adding specific arguments, deleting parts of a command, and converting commands between different operating system syntaxes like Linux.

```Shell
$> symsh "PowerShell edit registry entry"

# :Output:
# Set-ItemProperty -Path <path> -Name <name> -Value <value>

$> symsh "Set-ItemProperty -Path <path> -Name <name> -Value <value>" --add "path='/Users/myuser' name=Demo value=SymbolicAI"

# :Output:
# Set-ItemProperty -Path '/Users/myuser' -Name Demo -Value SymbolicAI

$> symsh "Set-ItemProperty -Path '/Users/myuser' -Name Demo -Value SymbolicAI" --del "string quotes"

# :Output:
# Set-ItemProperty -Path /Users/myuser -Name Demo -Value SymbolicAI

$> symsh "Set-ItemProperty -Path '/Users/myuser' -Name Demo -Value SymbolicAI" --convert "linux"

# :Output:
# export Demo="SymbolicAI"
```

--------------------------------

### Use Preview Mode for Symai Functions

Source: https://extensityai.gitbook.io/symbolicai/engines/neurosymbolic_engine

This example illustrates Symai's preview mode, allowing inspection of the *prepared* prompt before it is sent to the LLM engine. By setting preview=True on a Function call, developers can verify the exact input string, which is useful for debugging and understanding prompt construction.

```Python
from symai.components import Function

preview_fn = Function(
  "Return a JSON markdown string.",
  static_context="Static…",
  dynamic_context="Dynamic…"
)
# Instead of executing, retrieve prop.processed_input
preview = preview_fn("Hello, World!", preview=True)
assert preview.prop.processed_input == "Hello, World!"
```

--------------------------------

### Shell: Understand Package Initializer Command Syntax

Source: https://extensityai.gitbook.io/symbolicai/tools/packages

This snippet outlines the general syntax for using the `symdev` command-line tool, specifically for creating new packages. It shows how to specify the username and repository name for the new package. The `symdev` command automates the setup of new GitHub package structures.

```Shell
$> symdev c <username>/<repo_name>
```

--------------------------------

### Configure Local Embedding Engine with Llama.cpp

Source: https://extensityai.gitbook.io/symbolicai/engines/local_engine

This JSON snippet illustrates the configuration required to enable the `llama.cpp` backend for the embedding engine. It sets `EMBEDDING_ENGINE_MODEL` to `llamacpp` and leaves `EMBEDDING_ENGINE_API_KEY` empty, as local models do not require an external API key.

```JSON
{
  "EMBEDDING_ENGINE_API_KEY": "",
  "EMBEDDING_ENGINE_MODEL": "llamacpp",
  ...
}
```

--------------------------------

### Perform a Basic Query with Neuro-Symbolic Engine in Python

Source: https://extensityai.gitbook.io/symbolicai/engines/neurosymbolic_engine

This snippet demonstrates how to perform a one-off query using the `Symbol` class and the `query` method, which internally leverages the neuro-symbolic engine. It shows a simple translation example from English to German, illustrating the basic interaction with the engine.

```Python
from symai import Symbol, Expression

# A one-off question
res = Symbol("Hello, world!").query("Translate to German.")
print(res.value)
# → "Hallo, Welt!"
```

--------------------------------

### Python: Import GitHub-Hosted Package

Source: https://extensityai.gitbook.io/symbolicai/features/import

This snippet illustrates how to import a package hosted on GitHub using the `Import` class. The system automatically clones the repository, installs dependencies from `package.json` and `requirements.txt`, and makes the module's classes available for use in the project.

```Python
from symai import Import
symask_module = Import("ExtensityAI/symask")
```
Tokens:
Raw