langchain-prolog 0.1.0__tar.gz

langchain_prolog-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Antonio Pisani.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

langchain_prolog-0.1.0/PKG-INFO

@@ -0,0 +1,274 @@
+Metadata-Version: 2.3
+Name: langchain-prolog
+Version: 0.1.0
+Summary: An integration package connecting Prolog and LangChain
+License: MIT
+Keywords: langchain,prolog,swi-prolog,llm,agent
+Author: Antonio Pisani
+Requires-Python: >=3.10,<4.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Prolog
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: janus-swi (>=1.5.0,<2.0.0)
+Requires-Dist: langchain-core (>=0.3.0,<0.4.0)
+Requires-Dist: pydantic (>=2.0.0,<3.0.0)
+Project-URL: Repository, https://github.com/apisani1/langchain-prolog
+Project-URL: Release Notes, https://github.com/langchain-ai/langchain/releases?q=tag%3A%22prolog%3D%3D0%22&expanded=true
+Project-URL: Source Code, https://github.com/langchain-ai/langchain/tree/master/libs/partners/prolog
+Description-Content-Type: text/markdown
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![PyPI version](https://badge.fury.io/py/langchain-prolog.svg)](https://badge.fury.io/py/langchain-prolog)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/release/python-390/)
+[![Documentation Status](https://readthedocs.org/projects/langchain-prolog/badge/?version=latest)](https://langchain-prolog.readthedocs.io/en/latest/?badge=latest)
+![Version](https://img.shields.io/badge/version-0.1.0-blue)
+
+# LangChain-Prolog
+
+A Python library that integrates SWI-Prolog with LangChain, allowing seamless
+blending of Prolog's logic programming capabilities into LangChain applications.
+
+
+## Features
+
+- Seamless integration between LangChain and SWI-Prolog
+- Use Prolog queries as LangChain runnables and tools
+- Invoke Prolog predicates from LangChain 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 installed:
+    - langchain 0.3.0 or later
+    - janus-swi 1.5.0 or later
+    - pydantic 0.2.0 or later
+
+langchain-prolog can be installed using pip:
+```bash
+pip install langchain-prolog
+```
+
+## Runnable Interface
+
+The PrologRunnable class allows the generation of langchain runnables that use Prolog rules to generate answers.
+
+Let's assume that we have the following set of Prolog rules in the file family.pl:
+
+```prolog
+parent(john, bianca, mary).
+parent(john, bianca, michael).
+parent(peter, patricia, jennifer).
+partner(X, Y) :- parent(X, Y, _).
+```
+
+There are three diferent ways to use a PrologRunnable to query Prolog:
+
+#### 1) Using a Prolog runnable with a full predicate string
+
+```python
+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:
+```python
+[{'X': 'john', 'Y': 'bianca'},
+ {'X': 'john', 'Y': 'bianca'},
+ {'X': 'peter', 'Y': 'patricia'}]
+ ```
+
+#### 2) Using a Prolog runnable with a default predicate
+
+```python
+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):
+
+```python
+[{'X': 'patricia'}]
+```
+
+### 3) Using a Prolog runnable with a dictionary and schema validation
+
+```python
+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:
+```python
+[{'Man': 'john'}, {'Man': 'john'}]
+```
+
+You can also pass a Pydantic object generated with the schema to the invoke method:
+```python
+args = schema(man='M', woman='W')
+result = prolog.invoke(args)
+print(result)
+```
+Uppercase values are treated as variables:
+```python
+[{'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 assume that we have the following set of Prolog rules in the file family.pl:
+
+```prolog
+parent(john, bianca, mary).
+parent(john, bianca, michael).
+parent(peter, patricia, jennifer).
+partner(X, Y) :- parent(X, Y, _).
+```
+
+There are two ways to use a Prolog tool:
+
+### 1) Using a Prolog tool with an LLM and function calling
+
+First create the Prolog tool:
+```python
+from langchain_prolog import PrologConfig, PrologTool
+
+schema = PrologRunnable.create_schema('parent', ['men', 'women', '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 can be a query string like 'parent(john, X, Y)'
+        or 'john, X, Y'"
+        You have to specify 3 parameters: men, woman, child.
+        Do not use quotes.
+    """
+)
+```
+
+Then bind it to the LLM model and query the model:
+```python
+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:
+```python
+{'name': 'family_query',
+ 'args': {'men': 'john', 'women': None, 'child': None},
+ 'id': 'call_V6NUsJwhF41G9G7q6TBmghR0',
+ 'type': 'tool_call'}
+ ```
+ The tool takes this request and queries the Prolog database:
+ ```python
+ 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:
+ ```python
+ content='[{"Women": "bianca", "Child": "mary"}, {"Women": "bianca", "Child": "michael"}]'
+ name='family_query'
+ tool_call_id='call_V6NUsJwhF41G9G7q6TBmghR0'
+ ```
+ That we then pass to the LLM:
+ ```python
+ answer = llm_with_tools.invoke(messages)
+ print(answer.content)
+ ```
+ And the LLM answers the original query using the tool response:
+ ```python
+ John has two children: Mary and Michael. Their mother is Bianca.
+ ```
+
+### 2) Using a Prolog tool with an agent
+
+First create the Prolog tool:
+```python
+from langchain_prolog import PrologConfig, PrologTool
+
+schema = PrologRunnable.create_schema('parent', ['men', 'women', '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 can be a query string like 'parent(john, X, Y)'
+        or 'john, X, Y'"
+        You have to specify 3 parameters: men, woman, child.
+        Do not use quotes.
+    """
+)
+```
+Then pass it to the agent's constructor:
+```python
+from langchain_core.prompts import ChatPromptTemplate
+from langchain.agents import create_tool_calling_agent, AgentExecutor
+
+llm = ChatOpenAI(model="gpt-4o-mini")
+prompt = ChatPromptTemplate.from_messages(
+    [
+        ("system", "You are a helpful assistant"),
+        ("human", "{input}"),
+        ("placeholder", "{agent_scratchpad}"),
+    ]
+)
+tools = [prolog_tool]
+agent = create_tool_calling_agent(llm, tools, prompt)
+agent_executor = AgentExecutor(agent=agent, tools=tools)
+```
+The agent takes the query and use the Prolog tool if needed:
+```python
+answer = agent_executor.invoke({"input": "Who are John's children?"})
+print(answer)
+```
+Then the agent recieves the tool response as part of the {agent_scratchpad} placeholder and generates the answer:
+```python
+{'input': "Who are John's children?", 'output': 'John has two children: Mary and Michael, with Bianca as their mother.'}
+

langchain_prolog-0.1.0/README.md

@@ -0,0 +1,246 @@
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![PyPI version](https://badge.fury.io/py/langchain-prolog.svg)](https://badge.fury.io/py/langchain-prolog)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/release/python-390/)
+[![Documentation Status](https://readthedocs.org/projects/langchain-prolog/badge/?version=latest)](https://langchain-prolog.readthedocs.io/en/latest/?badge=latest)
+![Version](https://img.shields.io/badge/version-0.1.0-blue)
+
+# LangChain-Prolog
+
+A Python library that integrates SWI-Prolog with LangChain, allowing seamless
+blending of Prolog's logic programming capabilities into LangChain applications.
+
+
+## Features
+
+- Seamless integration between LangChain and SWI-Prolog
+- Use Prolog queries as LangChain runnables and tools
+- Invoke Prolog predicates from LangChain 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 installed:
+    - langchain 0.3.0 or later
+    - janus-swi 1.5.0 or later
+    - pydantic 0.2.0 or later
+
+langchain-prolog can be installed using pip:
+```bash
+pip install langchain-prolog
+```
+
+## Runnable Interface
+
+The PrologRunnable class allows the generation of langchain runnables that use Prolog rules to generate answers.
+
+Let's assume that we have the following set of Prolog rules in the file family.pl:
+
+```prolog
+parent(john, bianca, mary).
+parent(john, bianca, michael).
+parent(peter, patricia, jennifer).
+partner(X, Y) :- parent(X, Y, _).
+```
+
+There are three diferent ways to use a PrologRunnable to query Prolog:
+
+#### 1) Using a Prolog runnable with a full predicate string
+
+```python
+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:
+```python
+[{'X': 'john', 'Y': 'bianca'},
+ {'X': 'john', 'Y': 'bianca'},
+ {'X': 'peter', 'Y': 'patricia'}]
+ ```
+
+#### 2) Using a Prolog runnable with a default predicate
+
+```python
+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):
+
+```python
+[{'X': 'patricia'}]
+```
+
+### 3) Using a Prolog runnable with a dictionary and schema validation
+
+```python
+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:
+```python
+[{'Man': 'john'}, {'Man': 'john'}]
+```
+
+You can also pass a Pydantic object generated with the schema to the invoke method:
+```python
+args = schema(man='M', woman='W')
+result = prolog.invoke(args)
+print(result)
+```
+Uppercase values are treated as variables:
+```python
+[{'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 assume that we have the following set of Prolog rules in the file family.pl:
+
+```prolog
+parent(john, bianca, mary).
+parent(john, bianca, michael).
+parent(peter, patricia, jennifer).
+partner(X, Y) :- parent(X, Y, _).
+```
+
+There are two ways to use a Prolog tool:
+
+### 1) Using a Prolog tool with an LLM and function calling
+
+First create the Prolog tool:
+```python
+from langchain_prolog import PrologConfig, PrologTool
+
+schema = PrologRunnable.create_schema('parent', ['men', 'women', '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 can be a query string like 'parent(john, X, Y)'
+        or 'john, X, Y'"
+        You have to specify 3 parameters: men, woman, child.
+        Do not use quotes.
+    """
+)
+```
+
+Then bind it to the LLM model and query the model:
+```python
+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:
+```python
+{'name': 'family_query',
+ 'args': {'men': 'john', 'women': None, 'child': None},
+ 'id': 'call_V6NUsJwhF41G9G7q6TBmghR0',
+ 'type': 'tool_call'}
+ ```
+ The tool takes this request and queries the Prolog database:
+ ```python
+ 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:
+ ```python
+ content='[{"Women": "bianca", "Child": "mary"}, {"Women": "bianca", "Child": "michael"}]'
+ name='family_query'
+ tool_call_id='call_V6NUsJwhF41G9G7q6TBmghR0'
+ ```
+ That we then pass to the LLM:
+ ```python
+ answer = llm_with_tools.invoke(messages)
+ print(answer.content)
+ ```
+ And the LLM answers the original query using the tool response:
+ ```python
+ John has two children: Mary and Michael. Their mother is Bianca.
+ ```
+
+### 2) Using a Prolog tool with an agent
+
+First create the Prolog tool:
+```python
+from langchain_prolog import PrologConfig, PrologTool
+
+schema = PrologRunnable.create_schema('parent', ['men', 'women', '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 can be a query string like 'parent(john, X, Y)'
+        or 'john, X, Y'"
+        You have to specify 3 parameters: men, woman, child.
+        Do not use quotes.
+    """
+)
+```
+Then pass it to the agent's constructor:
+```python
+from langchain_core.prompts import ChatPromptTemplate
+from langchain.agents import create_tool_calling_agent, AgentExecutor
+
+llm = ChatOpenAI(model="gpt-4o-mini")
+prompt = ChatPromptTemplate.from_messages(
+    [
+        ("system", "You are a helpful assistant"),
+        ("human", "{input}"),
+        ("placeholder", "{agent_scratchpad}"),
+    ]
+)
+tools = [prolog_tool]
+agent = create_tool_calling_agent(llm, tools, prompt)
+agent_executor = AgentExecutor(agent=agent, tools=tools)
+```
+The agent takes the query and use the Prolog tool if needed:
+```python
+answer = agent_executor.invoke({"input": "Who are John's children?"})
+print(answer)
+```
+Then the agent recieves the tool response as part of the {agent_scratchpad} placeholder and generates the answer:
+```python
+{'input': "Who are John's children?", 'output': 'John has two children: Mary and Michael, with Bianca as their mother.'}

langchain_prolog-0.1.0/pyproject.toml

@@ -0,0 +1,94 @@
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry]
+name = "langchain-prolog"
+version = "0.1.0"
+description = "An integration package connecting Prolog and LangChain"
+authors = ["Antonio Pisani"]
+readme = "README.md"
+repository = "https://github.com/apisani1/langchain-prolog"
+license = "MIT"
+packages = [{ include = "langchain_prolog", from = "src" }]
+keywords = ["langchain", "prolog", "swi-prolog", "llm", "agent"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Prolog",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+include = [
+    { path = "src/langchain_prolog/*.pl", format = "sdist" },
+    { path = "src/langchain_prolog/*.pl", format = "wheel" }
+]
+
+[tool.poetry.urls]
+"Source Code" = "https://github.com/langchain-ai/langchain/tree/master/libs/partners/prolog"
+"Release Notes" = "https://github.com/langchain-ai/langchain/releases?q=tag%3A%22prolog%3D%3D0%22&expanded=true"
+
+[tool.poetry.dependencies]
+python = ">=3.10,<4.0"
+langchain-core = "^0.3.0"
+janus-swi = "^1.5.0"
+pydantic = "^2.0.0"
+
+[tool.coverage.run]
+omit = ["tests/*"]
+
+[tool.pytest.ini_options]
+addopts = "--strict-markers --strict-config --durations=5"
+markers = [
+    "compile: mark placeholder test used to compile integration tests without running them",
+    "integration: mark integration tests",
+    "requires_prolog: mark tests that require SWI-Prolog",]
+asyncio_mode = "auto"
+
+[tool.poetry.group.test]
+optional = true
+
+[tool.poetry.group.lint]
+optional = true
+
+[tool.poetry.group.dev]
+optional = true
+
+[tool.poetry.group.dev.dependencies]
+black = "^25.1.0"
+isort = "^6.0.0"
+mypy = "^1.15.0"
+
+[tool.poetry.group.test.dependencies]
+pytest = "^7.0.0"
+pytest-asyncio = "^0.21.0"
+
+[tool.poetry.group.lint.dependencies]
+flake8 = "^7.1.0"
+
+[tool.poetry.group.typing.dependencies]
+mypy = "^1.10"
+
+[tool.poetry.group.docs.dependencies]
+sphinx = "^8.1.3"
+sphinx-rtd-theme = "^3.0.2"
+myst-parser = "^4.0.0"
+sphinx-copybutton = "^0.5.2"
+
+[tool.black]
+line-length = 100
+target-version = ['py39']
+
+[tool.isort]
+profile = "black"
+line_length = 100
+
+[tool.mypy]
+python_version = "3.9"
+disallow_untyped_defs = true
+warn_return_any = true
+warn_unused_configs = true
+check_untyped_defs = true

langchain_prolog-0.1.0/src/langchain_prolog/__init__.py

@@ -0,0 +1,59 @@
+"""
+langchain_prolog - A LangChain integration for SWI-Prolog
+
+This module provides a bridge between LangChain and SWI-Prolog, allowing seamless
+integration of Prolog's logic programming capabilities into LangChain pipelines.
+
+Key Components:
+    - PrologConfig: Configuration class for Prolog settings
+    - PrologRunnable: Main class for executing Prolog queries
+    - PrologTool: Utility class for integrating Prolog queries into LangChain tools
+    - PrologResult: Type representing possible Prolog query results
+    - PrologInput: Type representing valid input formats
+    - PrologRuntimeError: Exception class for Prolog execution errors
+
+Requirements:
+    - Python 3.9 or higher
+    - LangChain 0.3.0 or higher
+    - Pydantic 2.0 or higher
+    - SWI-Prolog must be installed and accessible in the system path
+    - On macOS, requires Homebrew installation of SWI-Prolog
+    - The janus_swipl package must be installed
+"""
+
+from pydantic import ValidationError
+
+from ._prolog_init import initialize_prolog
+from .exceptions import (
+    PrologFileNotFoundError,
+    PrologInitializationError,
+    PrologRuntimeError,
+    PrologToolException,
+    PrologValueError,
+)
+from .runnable import (
+    PrologConfig,
+    PrologInput,
+    PrologResult,
+    PrologRunnable,
+)
+from .tool import PrologTool
+from .__version__ import __version__
+
+
+__all__ = [
+    "PrologConfig",
+    "PrologInput",
+    "PrologRunnable",
+    "PrologRuntimeError",
+    "PrologFileNotFoundError",
+    "PrologInitializationError",
+    "PrologToolException",
+    "PrologValueError",
+    "PrologResult",
+    "PrologTool",
+    "ValidationError",
+]
+
+# Initialize Prolog immediately when this module is imported
+initialize_prolog()

langchain_prolog-0.1.0/src/langchain_prolog/__version__.py

@@ -0,0 +1,3 @@
+VERSION = (0, 1, 0)  # Major, Minor, Patch
+
+__version__ = ".".join(map(str, VERSION))