Skip to main content

License: MIT PyPI version Python 3.10+ Documentation Status

LangChain-Prolog

A Python library that integrates SWI-Prolog with LangChain. It enables seamless blending of Prolog’s logic programming capabilities into LangChain applications, allowing rule-based reasoning, knowledge representation, and logical inference alongside GenAI models.

Features

  • Seamless integration between LangChain and SWI-Prolog
  • Use Prolog queries as LangChain's runnables and tools
  • Invoke Prolog predicates from LangChain's LLM models, chains and agents
  • Support for both synchronous and asynchronous operations
  • Comprehensive error handling and logging
  • Cross-platform support (macOS, Linux, Windows)

Installation

Prerequisites

  • Python 3.10 or later
  • SWI-Prolog installed on your system
  • The following Python libraries will be installed:
    • langchain 1.3.0 or later
    • janus-swi 1.5.0 or later
    • pydantic 2.7.0 or later

Once SWI-Prolog has been installed, langchain-prolog can be installed using pip:

pip install langchain-prolog

Runnable Interface

The PrologRunnable class allows the generation of langchain runnables that use Prolog rules to generate answers.

Let's use the following set of Prolog rules in the file family.pl:

parent(john, bianca, mary).
parent(john, bianca, michael).
parent(peter, patricia, jennifer).
partner(X, Y) :- parent(X, Y, _).

There are three ways to use a PrologRunnable to query Prolog:

1) Using a Prolog runnable with a full predicate string

from langchain_prolog import PrologConfig, PrologRunnable

config = PrologConfig(rules_file="family.pl")
prolog = PrologRunnable(prolog_config=config)
result = prolog.invoke("partner(X, Y)")
print(result)

We can pass a string representing a single predicate query. The invoke method will return True, False or a list of dictionaries with all the solutions to the query:

[{'X': 'john', 'Y': 'bianca'},
 {'X': 'john', 'Y': 'bianca'},
 {'X': 'peter', 'Y': 'patricia'}]

2) Using a Prolog runnable with a default predicate

from langchain_prolog import PrologConfig, PrologRunnable

config = PrologConfig(rules_file="family.pl", default_predicate="partner")
prolog = PrologRunnable(prolog_config=config)
result = prolog.invoke("peter, X")
print(result)

When using a default predicate, only the arguments for the predicate are passed to the Prolog runable, as a single string. Following Prolog conventions, uppercase identifiers are variables and lowercase identifiers are values (atoms or strings):

[{'X': 'patricia'}]

3) Using a Prolog runnable with a dictionary and schema validation

from langchain_prolog import PrologConfig, PrologRunnable

schema = PrologRunnable.create_schema("partner", ["man", "woman"])
config = PrologConfig(rules_file="family.pl", query_schema=schema)
prolog = PrologRunnable(prolog_config=config)
result = prolog.invoke({"man": None, "woman": "bianca"})
print(result)

If a schema is defined, we can pass a dictionary using the names of the parameters in the schema as the keys in the dictionary. The values can represent Prolog variables (uppercase first letter) or strings (lower case first letter). A None value is interpreted as a variable and replaced with the key capitalized:

[{'Man': 'john'}, {'Man': 'john'}]

You can also pass a Pydantic object generated with the schema to the invoke method:

args = schema(man='M', woman='W')
result = prolog.invoke(args)
print(result)

Uppercase values are treated as variables:

[{'M': 'john', 'W': 'bianca'},
 {'M': 'john', 'W': 'bianca'},
 {'M': 'peter', 'W': 'patricia'}]

Tool Interface

The PrologTool class allows the generation of langchain tools that use Prolog rules to generate answers.

See the Runnable Interface section for the conventions on hown to pass variables and values to the Prolog interpreter.

Let's use the following set of Prolog rules in the file family.pl:

parent(john, bianca, mary).
parent(john, bianca, michael).
parent(peter, patricia, jennifer).
partner(X, Y) :- parent(X, Y, _).

There are two diferent ways to use a PrologTool to query Prolog:

1) Using a Prolog tool with an LLM and function calling

First create the Prolog tool:

from langchain_prolog import PrologConfig, PrologRunnable, PrologTool

schema = PrologRunnable.create_schema("parent", ["man", "woman", "child"])
config = PrologConfig(
    rules_file="family.pl",
    query_schema=schema,
)
prolog_tool = PrologTool(
    prolog_config=config,
    name="family_query",
    description="""
        Query family relationships using Prolog.
        parent(X, Y, Z) implies only that Z is a child of X and Y.
        Input must be a dictionary like:
        {
            'man': 'richard',
            'woman': 'valery',
            'child': None,
        
        }
        Use 'None' to indicate a variable that need to be instantiated by Prolog
        The query will return:
            - 'True': if the relationship 'child' is a child of 'men' and 'women' holds.
            - 'False' if the relationship 'child' is a child of 'man' and 'woman' does not holds.
            - A list of dictionaries with all the answers to the Prolog query
        Do not use double quotes.
    """,
)

Then bind it to the LLM model and query the model:

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage

llm = ChatOpenAI(model="gpt-4o-mini")
llm_with_tools = llm.bind_tools([prolog_tool])
messages = [HumanMessage("Who are John's children?")]
response = llm_with_tools.invoke(messages)
messages.append(response)
print(response.tool_calls[0])

The LLM will respond with a tool call request:

{'name': 'family_query',
 'args': {'man': 'john', 'woman': None, 'child': None},
 'id': 'call_V6NUsJwhF41G9G7q6TBmghR0',
 'type': 'tool_call'}

The tool takes this request and queries the Prolog database:

tool_msg = prolog_tool.invoke(response.tool_calls[0])
messages.append(tool_msg)
print(tool_msg)

The tool returns a list with all the solutions for the query:

content='[{"Woman": "bianca", "Child": "mary"}, {"Woman": "bianca", "Child": "michael"}]'
name='family_query'
tool_call_id='call_V6NUsJwhF41G9G7q6TBmghR0'

That we then pass to the LLM:

answer = llm_with_tools.invoke(messages)
print(answer.content)

And the LLM answers the original query using the tool response:

John has two children: Mary and Michael. Their mother is Bianca.

2) Using a Prolog tool with a LangChain agent

First create the Prolog tool:

from langchain_prolog import PrologConfig, PrologRunnable, PrologTool

schema = PrologRunnable.create_schema("parent", ["man", "woman", "child"])
config = PrologConfig(
    rules_file="family.pl",
    query_schema=schema,
)
prolog_tool = PrologTool(
    prolog_config=config,
    name="family_query",
    description="""
        Query family relationships using Prolog.
        parent(X, Y, Z) implies only that Z is a child of X and Y.
        Input must be a dictionary like:
        {
            'man': 'richard',
            'woman': 'valery',
            'child': None,
        
        }
        Use 'None' to indicate a variable that need to be instantiated by Prolog
        The query will return:
            - 'True': if the relationship 'child' is a child of 'men' and 'women' holds.
            - 'False' if the relationship 'child' is a child of 'man' and 'woman' does not holds.
            - A list of dictionaries with all the answers to the Prolog query
        Do not use double quotes.
    """,
)

Then pass it to the agent's constructor:

from langchain.agents import create_agent

llm = ChatOpenAI(model="gpt-4o-mini")
agent_executor = create_agent(
    llm,
    [prolog_tool],
    system_prompt="You are a helpful assistant",
)

The agent takes the query and uses the Prolog tool if needed:

answer = agent_executor.invoke({"messages": [("human", "Who are John's children?")]})
print(answer["messages"][-1].content)

The agent receives the tool response and generates the answer:

John has two children: Mary and Michael. Their mother is Bianca.

Metadata

Release files for langchain-prolog 1.0.3

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for langchain-prolog 1.0.3
File Size Uploaded Provenance Actions
langchain_prolog-1.0.3.tar.gz 17.6 kB Without provenance Details for langchain_prolog-1.0.3.tar.gz

Built distribution (wheel)

Table of built distributions (wheels) for langchain-prolog 1.0.3
File Interpreter ABI Platform Actions
langchain_prolog-1.0.3-py3-none-any.whl Python 3 none any Details for langchain_prolog-1.0.3-py3-none-any.whl

Total release size: 36.4 kB

Release files / langchain_prolog-1.0.3.tar.gz

Download URL langchain_prolog-1.0.3.tar.gz
Size 17.6 kB
Tags Source
SHA-256 checksum
How to use checksums
dd72913dcb341b088ea086c8c52ab80fb14d93b184b113570fe5d95a8dda5c28
BLAKE2b-256 checksum
How to use checksums
53cb4c72c25a50e00b897e709fa52b9cf69c8edfa2749da464d5bf98bd17a424
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via uv/0.13.2 {"installer":{"name":"uv","version":"0.13.2","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"Ubuntu","version":"24.04","id":"noble","libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":true}

Release files / langchain_prolog-1.0.3-py3-none-any.whl

Download URL langchain_prolog-1.0.3-py3-none-any.whl
Size 18.8 kB
Tags Python 3
SHA-256 checksum
How to use checksums
25a78fba8ce96e91c086baf5bc3a0bdb8e59098647e64b7ce65f02c67415cfd9
BLAKE2b-256 checksum
How to use checksums
e7e9d7b39f20822ba84a556c385898df7c46fdc29f499c925ca8e010007551da
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via uv/0.13.2 {"installer":{"name":"uv","version":"0.13.2","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"Ubuntu","version":"24.04","id":"noble","libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":true}

Security for langchain-prolog 1.0.3

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

No provenance found

None of the files in this release were uploaded with provenance metadata.

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page