In this tutorial, we are browsing the hands-on fusion of symbolic logic and generating AI. We set up Pyswip to embed Preface Knowledge base, wrap its predicate as a lanchain tool, and then connect everything to a reactive proxy. In the process, we are developing family relationship rules, mathematical predicates such as factorization and listing utilities, then allowing agent planning, call tools, and justifications for the results. By the end of the setup we can issue natural language questions and watch the agent translate it into an exact prologue query, sew multi-step answers and return structured JSON-backed insights.
!apt-get install swi-prolog -y
!pip install pyswip langchain-google-genai langgraph langchain-coreWe installed Swi-Promog using APT-GET and then added Pyswip, Langchain’s Google Genai wrapper, Langgraph and Core Langchain packages via PIP so that we can bridge Prolog Logic with Gemini-Power’s proxy. With these dependencies, we can encode, query and coordinate inference end-to-end.
import os
from pyswip import Prolog
from langchain_google_genai import ChatGoogleGenerativeAI
from langchain_core.messages import HumanMessage
from langchain_core.tools import tool
from langgraph.prebuilt import create_react_agent
import json
GOOGLE_API_KEY = "Use Your Own API Key Here"
os.environ["GOOGLE_API_KEY"] = GOOGLE_API_KEY
llm = ChatGoogleGenerativeAI(model="gemini-1.5-flash", temperature=0)We loaded the core stack, including Prolog for the tool, Pyswip for Langchain and Langgraph, and Gemini 1.5 Flash for LLM Power. We then set the Google_api_key environment variable so that the model can authenticate. With LLM initializing at zero temperatures, we reveal the answer to certainty, logically grounded for our agents.
class AdvancedPrologInterface:
def __init__(self):
self.prolog = Prolog()
self._load_knowledge_base()
def _load_knowledge_base(self):
"""Load comprehensive Prolog knowledge base"""
rules = [
"parent(john, mary, alice)",
"parent(john, mary, bob)",
"parent(bob, susan, charlie)",
"parent(alice, david, emma)",
"parent(charlie, lisa, frank)",
"male(john)", "male(bob)", "male(david)", "male(charlie)", "male(frank)",
"female(mary)", "female(alice)", "female(susan)", "female(emma)", "female(lisa)",
"grandparent(X, Z) :- parent(X, _, Y), parent(Y, _, Z)",
"sibling(X, Y) :- parent(P1, P2, X), parent(P1, P2, Y), X \= Y",
"uncle(X, Y) :- sibling(X, Z), parent(Z, _, Y), male(X)",
"aunt(X, Y) :- sibling(X, Z), parent(Z, _, Y), female(X)",
"cousin(X, Y) :- parent(P1, _, X), parent(P2, _, Y), sibling(P1, P2)",
"factorial(0, 1)",
"factorial(N, F) :- N > 0, N1 is N - 1, factorial(N1, F1), F is N * F1",
"list_member(X, [X|_])",
"list_member(X, [_|T]) :- list_member(X, T)",
"list_length([], 0)",
"list_length([_|T], N) :- list_length(T, N1), N is N1 + 1",
"animal(dog)", "animal(cat)", "animal(whale)", "animal(eagle)",
"mammal(dog)", "mammal(cat)", "mammal(whale)",
"bird(eagle)", "bird(sparrow)",
"can_fly(eagle)", "can_fly(sparrow)",
"can_swim(whale)", "can_swim(fish)",
"aquatic_mammal(X) :- mammal(X), can_swim(X)"
]
for rule in rules:
try:
self.prolog.assertz(rule)
except Exception as e:
print(f"Warning: Could not assert rule '{rule}': {e}")
def query(self, query_string):
"""Execute Prolog query and return results"""
try:
results = list(self.prolog.query(query_string))
return results if results else [{"result": "No solutions found"}]
except Exception as e:
return [{"error": f"Query failed: {str(e)}"}]We wrap Swi-Prolog on a high-level Progologintface, load rich rules/factual basis on INIT, and then safely assert each clause. We will then expose a Query() method that runs any Prolog target and returns JSON-friendly results (or explicit error/no resolution messages), allowing us to directly drive logical queries from Python.
prolog_interface = AdvancedPrologInterface()
@tool
def family_relationships(query: str) -> str:
"""
Query family relationships in Prolog format.
Examples: 'parent(john, mary, X)', 'sibling(X, Y)', 'grandparent(X, charlie)'
"""
results = prolog_interface.query(query)
return json.dumps(results, indent=2)
@tool
def mathematical_operations(operation: str, number: int) -> str:
"""
Perform mathematical operations using Prolog.
Supported operations: 'factorial'
Example: operation='factorial', number=5
"""
if operation == "factorial":
query = f"factorial({number}, Result)"
results = prolog_interface.query(query)
return json.dumps(results, indent=2)
else:
return json.dumps([{"error": f"Operation '{operation}' not supported"}])
@tool
def advanced_queries(query_type: str, entity: str = "") -> str:
"""
Perform advanced relationship queries.
Types: 'all_children', 'all_grandchildren', 'all_siblings', 'all_cousins'
"""
queries = {
'all_children': f"parent(_, _, {entity})" if entity else "parent(_, _, X)",
'all_grandchildren': f"grandparent(_, {entity})" if entity else "grandparent(_, X)",
'all_siblings': f"sibling({entity}, X)" if entity else "sibling(X, Y)",
'all_cousins': f"cousin({entity}, X)" if entity else "cousin(X, Y)"
}
if query_type in queries:
results = prolog_interface.query(queries[query_type])
return json.dumps(results, indent=2)
else:
return json.dumps([{"error": f"Query type '{query_type}' not supported"}])We instantiate the Advanced Progologinterface and then query it as a Langchain tool (e.g. family_ryationships, Mathematical_operations, and Advanced_queries) so that we can call precise Prolog targets from natural language. We define each tool to format and dispatch the correct query (e.g. castorial/2 or cousin lookup) and return a clean JSON, allowing our agent to coordinate logical calls seamlessly.
tools = [family_relationships, mathematical_operations, advanced_queries]
agent = create_react_agent(llm, tools)
def run_family_analysis():
"""Comprehensive family relationship analysis"""
print("👨👩👧👦 Family Relationship Analysis")
print("=" * 50)
queries = [
"Who are all the parents in the family database?",
"Find all grandparent-grandchild relationships",
"Show me all the siblings in the family",
"Who are John and Mary's children?",
"Calculate the factorial of 6 using Prolog"
]
for i, query in enumerate(queries, 1):
print(f"n🔍 Query {i}: {query}")
print("-" * 30)
try:
response = agent.invoke({"messages": [("human", query)]})
answer = response["messages"][-1].content
print(f"🤖 Response: {answer}")
except Exception as e:
print(f"❌ Error: {str(e)}")
def demonstrate_complex_reasoning():
"""Show advanced multi-step reasoning"""
print("n🧠 Complex Multi-Step Reasoning")
print("=" * 40)
complex_query = """
I want a complete family tree analysis. Please:
1. List all parent-child relationships
2. Identify all grandparent relationships
3. Find any uncle/aunt relationships
4. Show cousin relationships
5. Calculate factorial of 4 as a bonus math operation
"""
print(f"Complex Query: {complex_query}")
print("-" * 40)
try:
response = agent.invoke({"messages": [("human", complex_query)]})
print(f"📋 Comprehensive Analysis:n{response['messages'][-1].content}")
except Exception as e:
print(f"❌ Error in complex reasoning: {str(e)}")
def interactive_prolog_session():
"""Interactive Prolog knowledge base exploration"""
print("n💬 Interactive Prolog Explorer")
print("Ask about family relationships, math operations, or general queries!")
print("Type 'examples' to see sample queries, 'quit' to exit")
print("-" * 50)
examples = [
"Who are Bob's children?",
"Find all grandparents in the family",
"Calculate factorial of 5",
"Show me all cousin relationships",
"Who are Alice's siblings?"
]
while True:
user_input = input("n🧑 You: ")
if user_input.lower() == 'quit':
print("👋 Goodbye!")
break
elif user_input.lower() == 'examples':
print("📝 Example queries:")
for ex in examples:
print(f" • {ex}")
continue
try:
response = agent.invoke({"messages": [("human", user_input)]})
print(f"🤖 AI: {response['messages'][-1].content}")
except Exception as e:
print(f"❌ Error: {str(e)}")We registered three prologue tools, namely, rotating a reaction agent around Gemini, then rotating the script assistant routine, run_family_analysis, explore_complex_reanote and an interactive loop to transmit the natural language query that the proxy translates to prolog calls. In this way, we test simple hints, multi-step reasoning and real-time Q&A while keeping the logic layer transparent and debateable.
def test_direct_queries():
"""Test direct Prolog queries for verification"""
print("n🔬 Direct Prolog Query Testing")
print("=" * 35)
test_queries = [
("parent(john, mary, X)", "Find John and Mary's children"),
("grandparent(X, charlie)", "Find Charlie's grandparents"),
("sibling(alice, X)", "Find Alice's siblings"),
("factorial(4, X)", "Calculate 4 factorial"),
("cousin(X, Y)", "Find all cousin pairs")
]
for query, description in test_queries:
print(f"n📋 {description}")
print(f"Query: {query}")
results = prolog_interface.query(query)
print(f"Results: {json.dumps(results, indent=2)}")
def main():
"""Main demonstration runner"""
if GOOGLE_API_KEY == "YOUR_GEMINI_API_KEY_HERE":
print("⚠️ Please set your Gemini API key in Cell 3!")
print("Get it from:
return
print("🚀 Advanced Prolog + Gemini Integration")
print("Using PySwip for stable Prolog integration")
print("=" * 55)
test_direct_queries()
run_family_analysis()
demonstrate_complex_reasoning()
def show_mathematical_capabilities():
"""Demonstrate mathematical reasoning with Prolog"""
print("n🔢 Mathematical Reasoning with Prolog")
print("=" * 40)
math_queries = [
"Calculate factorial of 3, 4, and 5",
"What is the factorial of 7?",
"Show me how factorial calculation works step by step"
]
for query in math_queries:
print(f"n🧮 Math Query: {query}")
try:
response = agent.invoke({"messages": [("human", query)]})
print(f"📊 Result: {response['messages'][-1].content}")
except Exception as e:
print(f"❌ Error: {str(e)}")
if __name__ == "__main__":
main()
show_mathematical_capabilities()
print("n✅ Tutorial completed successfully!")
print("🎯 Key achievements:")
print(" • Integrated PySwip with Gemini AI")
print(" • Created advanced Prolog reasoning tools")
print(" • Demonstrated complex family relationship queries")
print(" • Implemented mathematical operations in Prolog")
print(" • Built interactive AI agent with logical reasoning")
print("n🚀 Try extending with your own Prolog rules and facts!")We connect everything to Main() to validate our prologue goal, run family analysis and show multi-step reasoning, and then show_mathematical_capabilities() emphasizes paragraph queries in paragraphs. Finally, we can confidently extend the stack to the next new rules or exchange models by printing a quick review of what has been built to date.
In short, we have shown that symbolic reasoning and LLM complement each other: Prolog guarantees correctness for well-defined logic, while Gemini handles flexible language understanding and orchestration. We will provide effective scaffolding, direct prologue queries, tool wrapping predicates for validation, proxy, and demonstration features for complex genealogy and mathematical analysis. From here we are ready to expand our knowledge base, add new areas (such as financial rules, game logic and knowledge graphs) or exchange them in different LLMSs. We can also expose this stack through an interactive UI or API, allowing others to explore logically booted AI in real time.
Check Complete code. All credits for this study are to the researchers on the project.
Researchers with Nvidia, OpenAI, DeepMind, Meta, Microsoft, JP Morgan Chase, Amgan, Amgan, Aflac, Aflac, Wells Fargo and 100s read AI Dev newsletters and researchers read. [SUBSCRIBE NOW]
Asif Razzaq is CEO of Marktechpost Media Inc. As a visionary entrepreneur and engineer, ASIF is committed to harnessing the potential of artificial intelligence to achieve social benefits. His recent effort is to launch Marktechpost, an artificial intelligence media platform that has an in-depth coverage of machine learning and deep learning news that can sound both technically, both through technical voices and be understood by a wide audience. The platform has over 2 million views per month, demonstrating its popularity among its audience.
