# Neuro-symbolic open-source AI frameworks · SynaLinks

> https://synalinks.com/en/open-source/

Open source

# The two engines of SynaLemma are open source

Synalinks for the agent, Synalog for the logic: both Apache-2.0 and developed in public. Because the code is public, anyone can check how SynaLemma's engines verify a rule and compute an answer.

This page is technical. For your business, it means that the engines under SynaLemma can be inspected by anyone, and that your rules remain readable outside our product. [See SynaLemma](/en/synalemma)

*   **1.4k** GitHub stars
*   **180k** PyPI downloads
*   **Apache-2.0** licence

Synalinks

## A neuro-symbolic framework for applications built on language models

*   Neuro-symbolic
*   Agents
*   RAG
*   In-context RL
*   Embedded sandbox
*   Knowledge graphs
*   Structured output
*   Python

Synalinks is a framework for building, training, and deploying language-model applications (RAG pipelines, autonomous agents, and self-evolving reasoning systems) with a clean, declarative API inherited from Keras. It brings deep-learning discipline to AI systems: compose components, optimize their instructions against real metrics without touching model weights, run agent code in an embedded sandbox, and deploy the result as an API or an MCP server. Developed under the supervision of François Chollet, the author of Keras.

**Why it matters for you:** SynaLemma's assistant is built on it, so its outputs are held to a schema and its instructions are optimized against measured results.

★ 467 125k downloads

[GitHub](https://github.com/SynaLinks/synalinks) [Documentation](https://synalinks.github.io/synalinks)

A program, built and trained the Keras way

program.py Copy

```
import synalinks

class Question(synalinks.DataModel):
    question: str

class Answer(synalinks.DataModel):
    answer: str

lm = synalinks.LanguageModel(model="ollama/qwen3.8:27b", supports_reasoning=True)

inputs = synalinks.Input(data_model=Question)
outputs = await synalinks.ChainOfThought(data_model=Answer, language_model=lm)(inputs)
program = synalinks.Program(inputs=inputs, outputs=outputs)

program.compile(reward="exactmatch", optimizer="randomfewshot")
await program.fit(x=x_train, y=y_train, epochs=3)
```

Synalog

## Turning raw tables into structured, verified knowledge

*   Logic engine
*   Datalog
*   Knowledge graphs
*   Compiles to SQL
*   Formal verification

Synalog is a logic language of the Datalog family, written in Rust, that compiles to seven SQL dialects. A formal verifier refuses a badly built rule before any SQL is generated, and assertions in first-order logic, written in Lean's notation, search your data for counterexamples. Knowledge graphs over your tables, bounded recursion, reasoning over time: nothing is copied, everything runs in your database.

**Why it matters for you:** your business rules become code that is verified before it runs, and every answer traces back to the data that produced it, which is what a customer or a regulator will ask you to show.

★ 19 55k downloads

[GitHub](https://github.com/SynaLinks/synalog) [Documentation](https://synalinks.github.io/synalog) [Try it in the browser](https://synalinks.github.io/synalog/playground/)

A bill of materials through every level, with its assertions

concepts/requires.l Copy

```
---
name: Requires
description: An assembly requires a component, directly or inside a sub-assembly, at any level of the bill of materials.
---
import concepts.contains.Contains;

@Assert(Requires,
        no_cycle: "∀ a, ¬ Requires a a",
        transitive: "∀ a b c, Requires a b → Requires b c → Requires a c",
        includes_direct: "∀ a c q, Contains a c q → Requires a c");
@Recursive(Requires, 20);
@OrderBy(Requires, "assembly_id", "component_id");
Requires(assembly_id:, component_id:) distinct :- Contains(assembly_id:, component_id:);
Requires(assembly_id:, component_id:) distinct :-
  Requires(assembly_id:, component_id: middle), Contains(assembly_id: middle, component_id:);
```

Synalinks Skills

## Synalinks expertise, packaged for coding agents

*   Agent Skills
*   SKILL.md
*   Claude Code
*   Codex
*   OpenCode
*   pi
*   Runnable examples
*   Reference docs

Synalinks Skills is a library of skills in the open `SKILL.md` format that teaches coding agents to write idiomatic Synalinks: scannable guides, runnable scripts, and deep-dive references covering the framework end to end. Without that guidance, a model mixes syntaxes and produces plausible-looking but broken code. With it, coding agents write Synalinks the way our team does.

**Why it matters for you:** turning know-how into instructions a machine follows is what SynaLemma does with your teams' definitions.

★ 911

[GitHub](https://github.com/SynaLinks/synalinks-skills)

Our research

## Six subjects, one thread: making AI systems measurable and defensible

Six areas of applied research, from neuro-symbolic reasoning to evaluating AI systems.

*   ### In-context optimization
    
    Improving an AI system without retraining a single weight: its instructions and examples are optimized against a measurable reward, the way you'd train a model.
    
    *   In-context RL
    *   Evolutionary optimizers
    *   Quality-diversity
*   ### Evaluating AI systems
    
    How you know a system answers correctly, and that it hasn't degraded since yesterday.
    
    *   Metrics
    *   Automated judges
    *   Regression testing
*   ### Neuro-symbolic reasoning
    
    Constraining a language model with structure and logic: outputs that are valid by construction, reasoning you can inspect, and conclusions that trace back to their premises rather than to a statistical hunch.
    
    *   Structured output
    *   Logic
    *   Verification
*   ### Knowledge graphs
    
    Turning documents into graphs a system can use, then querying those graphs: local search for precise questions, global search for questions that span an entire corpus.
    
    *   KG extraction
    *   GraphRAG
    *   Local & global search
*   ### Agents and confined execution
    
    An agent that writes and runs code is useful, and dangerous. We work on confining it: filesystem isolation, restricted system calls, controlled network access, capabilities granted explicitly rather than by default.
    
    *   Sandboxing
    *   Confinement
    *   Agent tooling
*   ### Self-evolving programs
    
    Pipelines where the model produces its own examples, the symbolic layer verifies them and discards what doesn't hold, and only what survives feeds the next step.
    
    *   Self-distillation
    *   Synthetic data
    *   Symbolic filtering

The product

### SynaLemma is built on these engines

Our commercial product puts them to work on your business data: answers that cite the rule behind every number, on your servers, with the model you choose.

[Book a demo](https://calendar.app.google/RMMAPbHYroAgiokb7)

Community

### Built in the open, with a community around it

Our frameworks are Apache-2.0 and developed in public. Star the repos, open an issue, or join the conversation. To use these engines on your own data, start with SynaLemma.

[Join the Discord](https://discord.gg/82nt97uXcM) [Talk to us about your project](/en/contact)
