biblemate 0.0.22__tar.gz → 0.0.24__tar.gz

{biblemate-0.0.22 → biblemate-0.0.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: biblemate
-Version: 0.0.22
+Version: 0.0.24
 Summary: BibleMate AI - Automate Your Bible Study
 Home-page: https://toolmate.ai
 Author: Eliran Wong

{biblemate-0.0.22 → biblemate-0.0.24}/biblemate/bible_study_mcp.py

@@ -1,5 +1,6 @@
 import logging
 from fastmcp import FastMCP
+from fastmcp.prompts.prompt import PromptMessage, TextContent
 from agentmake import agentmake
 from biblemate import AGENTMAKE_CONFIG
 
@@ -347,4 +348,22 @@ def write_bible_sermon(request:str) -> str:
     messages = agentmake(request, **{'instruction': 'bible/sermon', 'system': 'auto'}, **AGENTMAKE_CONFIG)
     return getResponse(messages)
 
+@mcp.prompt
+def simple_bible_study(request:str) -> PromptMessage:
+    """Perform a simple bible study task; bible reference(s) must be given"""
+    global PromptMessage, TextContent
+    prompt_text = f"""You are a bible study agent. You check the user request, under the `User Request` section, and resolve it with the following steps in order:
+1. Call tool 'retrieve_english_bible_verses' for Bible text, 
+2. Call tool 'retrieve_bible_cross_references' for Bible cross-references, 
+3. Call tool 'study_old_testament_themes' for study old testament themes or 'study_new_testament_themes' for study old testament themes, and 
+4. Call tool 'write_bible_theology' to explain its theology.
+
+# User Request
+
+---
+{request}
+---
+"""
+    return PromptMessage(role="user", content=TextContent(type="text", text=prompt_text))
+
 mcp.run(show_banner=False)

biblemate-0.0.24/biblemate/config.py

@@ -0,0 +1,3 @@
+agent_mode=True
+prompt_engineering=True
+max_steps=30

{biblemate-0.0.22 → biblemate-0.0.24}/biblemate/main.py

@@ -3,7 +3,7 @@ from biblemate.ui.prompts import getInput
 from biblemate.ui.info import get_banner
 from biblemate import config, AGENTMAKE_CONFIG
 from pathlib import Path
-import asyncio, re, os, subprocess
+import asyncio, re, os, subprocess, click
 from alive_progress import alive_bar
 from fastmcp import Client
 from agentmake import agentmake, getOpenCommand, getDictionaryOutput, edit_configurations, writeTextFile, getCurrentDateTime, AGENTMAKE_USER_DIR, USER_OS, DEVELOPER_MODE
@@ -14,88 +14,119 @@ from rich.terminal_theme import MONOKAI
 if not USER_OS == "Windows":
     import readline  # for better input experience
 
-# Client to interact with the built-in Bible Study MCP server
-client = Client(os.path.join(os.path.dirname(os.path.realpath(__file__)), "bible_study_mcp.py"))
-
-# TODO: place in config.py
-MAX_STEPS = 50
+# The client that interacts with the Bible Study MCP server
+builtin_mcp_server = os.path.join(os.path.dirname(os.path.realpath(__file__)), "bible_study_mcp.py")
+user_mcp_server = os.path.join(AGENTMAKE_USER_DIR, "biblemate", "bible_study_mcp.py") # The user path has the same basename as the built-in one; users may copy the built-in server settings to this location for customization. 
+client = Client(user_mcp_server if os.path.isfile(user_mcp_server) else builtin_mcp_server)
 
 def main():
     asyncio.run(main_async())
 
+async def initialize_app(client):
+    """Initializes the application by fetching tools and prompts from the MCP server."""
+    await client.ping()
+
+    tools_raw = await client.list_tools()
+    tools = {t.name: t.description for t in tools_raw}
+    tools = dict(sorted(tools.items()))
+    tools_schema = {}
+    for t in tools_raw:
+        schema = {
+            "name": t.name,
+            "description": t.description,
+            "parameters": {
+                "type": "object",
+                "properties": t.inputSchema["properties"],
+                "required": t.inputSchema["required"],
+            },
+        }
+        tools_schema[t.name] = schema
+
+    available_tools = list(tools.keys())
+    if "get_direct_text_response" not in available_tools:
+        available_tools.insert(0, "get_direct_text_response")
+
+    tool_descriptions = ""
+    if "get_direct_text_response" not in tools:
+        tool_descriptions = """# TOOL DESCRIPTION: `get_direct_text_response`
+Get a static text-based response directly from a text-based AI model without using any other tools. This is useful when you want to provide a simple and direct answer to a question or request, without the need for online latest updates or task execution.\n\n\n"""
+    for tool_name, tool_description in tools.items():
+        tool_descriptions += f"""# TOOL DESCRIPTION: `{tool_name}`
+{tool_description}\n\n\n"""
+
+    prompts_raw = await client.list_prompts()
+    prompts = {p.name: p.description for p in prompts_raw}
+    prompts = dict(sorted(prompts.items()))
+
+    prompts_schema = {}
+    for p in prompts_raw:
+        arg_properties = {}
+        arg_required = []
+        for a in p.arguments:
+            arg_properties[a.name] = {
+                "type": "string",
+                "description": str(a.description) if a.description else "no description available",
+            }
+            if a.required:
+                arg_required.append(a.name)
+        schema = {
+            "name": p.name,
+            "description": p.description,
+            "parameters": {
+                "type": "object",
+                "properties": arg_properties,
+                "required": arg_required,
+            },
+        }
+        prompts_schema[p.name] = schema
+    
+    return tools, tools_schema, available_tools, tool_descriptions, prompts, prompts_schema
+
+def backup_conversation(console, messages, master_plan):
+    """Backs up the current conversation to the user's directory."""
+    timestamp = getCurrentDateTime()
+    storagePath = os.path.join(AGENTMAKE_USER_DIR, "biblemate", timestamp)
+    Path(storagePath).mkdir(parents=True, exist_ok=True)
+    # Save full conversation
+    conversation_file = os.path.join(storagePath, "conversation.py")
+    writeTextFile(conversation_file, str(messages))
+    # Save master plan
+    writeTextFile(os.path.join(storagePath, "master_plan.md"), master_plan)
+    # Save html
+    html_file = os.path.join(storagePath, "conversation.html")
+    console.save_html(html_file, inline_styles=True, theme=MONOKAI)
+    # Save markdown
+    console.save_text(os.path.join(storagePath, "conversation.md"))
+    # Inform users of the backup location
+    print(f"Conversation backup saved to {storagePath}")
+    print(f"Report saved to {html_file}\n")
+
+def write_user_config():
+    """Writes the current configuration to the user's config file."""
+    user_config_dir = os.path.join(AGENTMAKE_USER_DIR, "biblemate")
+    Path(user_config_dir).mkdir(parents=True, exist_ok=True)
+    config_file = os.path.join(user_config_dir, "config.py")
+    configurations = f"""agent_mode={config.agent_mode}
+prompt_engineering={config.prompt_engineering}
+max_steps={config.max_steps}"""
+    writeTextFile(config_file, configurations)
+
 async def main_async():
 
+    APP_START = True
+    DEFAULT_SYSTEM = "You are BibleMate AI, an autonomous agent designed to assist users with their Bible study."
     console = Console(record=True)
     console.clear()
     console.print(get_banner())
 
     async with client:
-        await client.ping()
-
-        #resources = await client.list_resources()
-        #print("# Resources\n\n", resources, "\n\n")
-
-        # List available tools, resources, and prompts
-        tools_raw = await client.list_tools()
-        #print(tools_raw)
-        tools = {t.name: t.description for t in tools_raw}
-        tools = dict(sorted(tools.items()))
-        tools_schema = {}
-        for t in tools_raw:
-            schema = {
-                "name": t.name,
-                "description": t.description,
-                "parameters": {
-                    "type": "object",
-                    "properties": t.inputSchema["properties"],
-                    "required": t.inputSchema["required"],
-                },
-            }
-            tools_schema[t.name] = schema
-
-        available_tools = list(tools.keys())
-        if not "get_direct_text_response" in available_tools:
-            available_tools.insert(0, "get_direct_text_response")
+        tools, tools_schema, available_tools, tool_descriptions, prompts, prompts_schema = await initialize_app(client)
+        
         available_tools_pattern = "|".join(available_tools)
-
-        # add tool description for get_direct_text_response if not exists
-        if not "get_direct_text_response" in tools:
-            tool_descriptions = f"""# TOOL DESCRIPTION: `get_direct_text_response`
-Get a static text-based response directly from a text-based AI model without using any other tools. This is useful when you want to provide a simple and direct answer to a question or request, without the need for online latest updates or task execution.\n\n\n"""
-        # add tool descriptions
-        for tool_name, tool_description in tools.items():
-            tool_descriptions += f"""# TOOL DESCRIPTION: `{tool_name}`
-{tool_description}\n\n\n"""
-
-        prompts_raw = await client.list_prompts()
-        #print("# Prompts\n\n", prompts_raw, "\n\n")
-        prompts = {p.name: p.description for p in prompts_raw}
         prompt_list = [f"/{p}" for p in prompts.keys()]
         prompt_pattern = "|".join(prompt_list)
         prompt_pattern = f"""^({prompt_pattern}) """
 
-        prompts_schema = {}
-        for p in prompts_raw:
-            arg_properties = {}
-            arg_required = []
-            for a in p.arguments:
-                arg_properties[a.name] = {
-                    "type": "string",
-                    "description": str(a.description) if a.description else "no description available",
-                }
-                if a.required:
-                    arg_required.append(a.name)
-            schema = {
-                "name": p.name,
-                "description": p.description,
-                "parameters": {
-                    "type": "object",
-                    "properties": arg_properties,
-                    "required": arg_required,
-                },
-            }
-            prompts_schema[p.name] = schema
-
         user_request = ""
         master_plan = ""
         messages = []
@@ -139,33 +170,24 @@ Get a static text-based response directly from a text-based AI model without usi
                 # Await the custom async progress bar that awaits the task.
                 await async_alive_bar(task)
 
-            # backup
-            def backup():
-                nonlocal console, messages, master_plan
-                timestamp = getCurrentDateTime()
-                storagePath = os.path.join(AGENTMAKE_USER_DIR, "biblemate", timestamp)
-                Path(storagePath).mkdir(parents=True, exist_ok=True)
-                # Save full conversation
-                conversation_file = os.path.join(storagePath, "conversation.py")
-                writeTextFile(conversation_file, str(messages))
-                # Save master plan
-                writeTextFile(os.path.join(storagePath, "master_plan.md"), master_plan)
-                # Save html
-                html_file = os.path.join(storagePath, "conversation.html")
-                console.save_html(html_file, inline_styles=True, theme=MONOKAI)
-                # Save markdown
-                console.save_text(os.path.join(storagePath, "conversation.md"))
-                # Inform users of the backup location
-                print(f"Conversation backup saved to {storagePath}")
-                print(f"Report saved to {html_file}\n")
-            def write_config():
-                # TODO: support more configs
-                config_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), "config.py")
-                writeTextFile(config_file, f"agent_mode={config.agent_mode}")
-
             if messages:
                 console.rule()
-
+            elif APP_START:
+                print()
+                APP_START = False
+                while True:
+                    try:
+                        agentmake("Hello!", system=DEFAULT_SYSTEM)
+                        break
+                    except Exception as e:
+                        print("Connection failed! Please ensure that you have a stable internet connection and that my AI backend and model are properly configured.")
+                        print("Viist https://github.com/eliranwong/agentmake#supported-backends for help about the backend configuration.\n")
+                        if click.confirm("Do you want to configure my AI backend and model now?", default=True):
+                            edit_configurations()
+                            console.rule()
+                            console.print("Restart to make the changes in the backend effective!", justify="center")
+                            console.rule()
+                            exit()
             # Original user request
             # note: `python3 -m rich.emoji` for checking emoji
             console.print("Enter your request :smiley: :" if not messages else "Enter a follow-up request :flexed_biceps: :")
@@ -176,14 +198,30 @@ Get a static text-based response directly from a text-based AI model without usi
                 ".chat": "enable chat mode",
                 ".agent": "enable agent mode",
                 ".tools": "list available tools",
-                #".resources": "list available resources",
-                #".prompts": "list available prompts",
+                ".plans": "list available plans",
+                #".resources": "list available resources", # TODO explore relevant usage for this project
+                ".promptengineering": "toggle auto prompt engineering",
+                ".steps": "configure the maximum number of steps allowed",
                 ".backup": "backup conversation",
                 ".open": "open a file or directory",
+                ".help": "help page",
             }
             input_suggestions = list(action_list.keys())+[f"@{t} " for t in available_tools]+prompt_list
             user_request = await getInput("> ", input_suggestions)
             while not user_request.strip():
+                # Generate ideas for `prompts to try`
+                ideas = ""
+                async def generate_ideas():
+                    nonlocal ideas
+                    if not messages:
+                        ideas = agentmake("Generate three `prompts to try` for bible study. Each one should be one sentence long.", **AGENTMAKE_CONFIG)[-1].get("content", "").strip()
+                    else:
+                        ideas = agentmake(messages, follow_up_prompt="Generate three follow-up questions according to the on-going conversation.", **AGENTMAKE_CONFIG)[-1].get("content", "").strip()
+                await thinking(generate_ideas, "Generating ideas ...")
+                console.rule()
+                console.print(Markdown(f"## Ideas\n\n{ideas}\n\n"))
+                console.rule()
+                # Get input agin
                 user_request = await getInput("> ", input_suggestions)
 
             # system command
@@ -194,34 +232,58 @@ Get a static text-based response directly from a text-based AI model without usi
                 subprocess.Popen(cmd, shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
                 continue
 
-            # TODO: ui - radio list menu
+            # predefined operations with `.` commands
             if user_request in action_list:
                 if user_request == ".backup":
-                    backup()
+                    backup_conversation(console, messages, master_plan)
+                elif user_request == ".help":
+                    console.rule()
+                    console.print(Markdown("Viist https://github.com/eliranwong/biblemate for help."))
+                    console.rule()
                 elif user_request == ".tools":
                     console.rule()
                     tools_descriptions = [f"- `{name}`: {description}" for name, description in tools.items()]
                     console.print(Markdown("## Available Tools\n\n"+"\n".join(tools_descriptions)))
                     console.rule()
+                elif user_request == ".plans":
+                    console.rule()
+                    prompts_descriptions = [f"- `{name}`: {description}" for name, description in prompts.items()]
+                    console.print(Markdown("## Available Plans\n\n"+"\n".join(prompts_descriptions)))
+                    console.rule()
                 elif user_request == ".backend":
                     edit_configurations()
                     console.rule()
                     console.print("Restart to make the changes in the backend effective!", justify="center")
                     console.rule()
+                elif user_request == ".steps":
+                    console.rule()
+                    console.print("Enter the maximum number of steps allowed below:")
+                    max_steps = await getInput("> ", number_validator=True)
+                    if max_steps:
+                        config.max_steps = int(max_steps)
+                        write_user_config()
+                        console.print("Maximum number of steps set to", config.max_steps, "steps.", justify="center")
+                    console.rule()
+                elif user_request == ".promptengineering":
+                    config.prompt_engineering = not config.prompt_engineering
+                    write_user_config()
+                    console.rule()
+                    console.print("Prompt Engineering Enabled" if config.prompt_engineering else "Prompt Engineering Disabled", justify="center")
+                    console.rule()
                 elif user_request == ".chat":
                     config.agent_mode = False
-                    write_config()
+                    write_user_config()
                     console.rule()
                     console.print("Chat Mode Enabled", justify="center")
                     console.rule()
                 elif user_request == ".agent":
                     config.agent_mode = True
-                    write_config()
+                    write_user_config()
                     console.rule()
                     console.print("Agent Mode Enabled", justify="center")
                     console.rule()
                 elif user_request in (".new", ".quit"):
-                    backup() # backup
+                    backup_conversation(console, messages, master_plan) # backup
                 # reset
                 if user_request == ".new":
                     user_request = ""
@@ -231,8 +293,12 @@ Get a static text-based response directly from a text-based AI model without usi
                 continue
 
             # Check if a single tool is specified
+            specified_prompt = ""
             specified_tool = ""
-            if re.search(f"""^@({available_tools_pattern}) """, user_request):
+            if re.search(prompt_pattern, user_request):
+                specified_prompt = re.search(prompt_pattern, user_request).group(1)
+                user_request = user_request[len(specified_prompt):]
+            elif re.search(f"""^@({available_tools_pattern}) """, user_request):
                 specified_tool = re.search(f"""^@({available_tools_pattern}) """, user_request).group(1)
                 user_request = user_request[len(specified_tool)+2:]
             elif user_request.startswith("@@"):
@@ -249,7 +315,7 @@ Get a static text-based response directly from a text-based AI model without usi
                 console.print(Markdown(f"# User Request\n\n{user_request}\n\n# Master plan\n\n{master_plan}"))
 
             # Prompt Engineering
-            if not specified_tool == "@@":
+            if not specified_tool == "@@" and config.prompt_engineering:
                 async def run_prompt_engineering():
                     nonlocal user_request
                     user_request = agentmake(messages if messages else user_request, follow_up_prompt=user_request if messages else None, tool="improve_prompt", **AGENTMAKE_CONFIG)[-1].get("content", "").strip()[20:-4]
@@ -257,7 +323,7 @@ Get a static text-based response directly from a text-based AI model without usi
 
             if not messages:
                 messages = [
-                    {"role": "system", "content": "You are BibleMate, an autonomous AI agent."},
+                    {"role": "system", "content": DEFAULT_SYSTEM},
                     {"role": "user", "content": user_request},
                 ]
             else:
@@ -303,22 +369,19 @@ Get a static text-based response directly from a text-based AI model without usi
 
             # generate master plan
             if not master_plan:
-                if re.search(prompt_pattern, user_request):
-                    prompt_name = re.search(prompt_pattern, user_request).group(1)
-                    user_request = user_request[len(prompt_name):]
+                if specified_prompt:
                     # Call the MCP prompt
-                    prompt_schema = prompts_schema[prompt_name[1:]]
+                    prompt_schema = prompts_schema[specified_prompt[1:]]
                     prompt_properties = prompt_schema["parameters"]["properties"]
                     if len(prompt_properties) == 1 and "request" in prompt_properties: # AgentMake MCP Servers or alike
-                        result = await client.get_prompt(prompt_name[1:], {"request": user_request})
+                        result = await client.get_prompt(specified_prompt[1:], {"request": user_request})
                     else:
                         structured_output = getDictionaryOutput(messages=messages, schema=prompt_schema)
-                        result = await client.get_prompt(prompt_name[1:], structured_output)
+                        result = await client.get_prompt(specified_prompt[1:], structured_output)
                     #print(result, "\n\n")
                     master_plan = result.messages[0].content.text
                     # display info# display info
                     console.print(Markdown(f"# User Request\n\n{user_request}\n\n# Master plan\n\n{master_plan}"))
-                    console.print(Markdown(f"# User Request\n\n{user_request}\n\n# Master plan\n\n{master_plan}"))
                 else:
                     # display info
                     console.print(Markdown(f"# User Request\n\n{user_request}"), "\n")
@@ -408,9 +471,10 @@ Available tools are: {available_tools}.
 
                 # iteration count
                 step += 1
-                if step > MAX_STEPS:
-                    print("Stopped! Too many steps! `MAX_STEPS` is currently set to ", MAX_STEPS, "!")
-                    print("You can increase it in the settings, but be careful not to create an infinite loop!")
+                if step > config.max_steps:
+                    console.rule()
+                    console.print("Stopped! Too many steps! The maximum steps is currently set to", config.max_steps, "steps. Enter `.steps` to configure.")
+                    console.rule()
                     break
 
                 # Get the next suggestion
@@ -426,7 +490,7 @@ Available tools are: {available_tools}.
                 messages.append({"role": "assistant", "content": next_suggestion})
 
             # Backup
-            backup()
+            backup_conversation(console, messages, master_plan)
 
 if __name__ == "__main__":
     asyncio.run(main())

{biblemate-0.0.22 → biblemate-0.0.24}/biblemate/requirements.txt

@@ -2,4 +2,5 @@ agentmake>=1.0.70
 agentmakemcp>=0.0.8
 fastmcp[cli]
 rich
-alive-progress
+alive-progress
+click

{biblemate-0.0.22 → biblemate-0.0.24}/biblemate/ui/prompts.py

@@ -1,9 +1,26 @@
 from agentmake.main import AGENTMAKE_USER_DIR
 from agentmake.utils.system import getCliOutput
-import os, shutil
+from prompt_toolkit.validation import Validator, ValidationError
+from biblemate import config
+import os, shutil, re
 
 
-async def getInput(prompt:str="Instruction: ", input_suggestions:list=None):
+class NumberValidator(Validator):
+    def validate(self, document):
+        text = document.text
+
+        if text and not re.search("^[0-9]+?$", text):
+            i = 0
+
+            # Get index of first non numeric character.
+            # We want to move the cursor here.
+            for i, c in enumerate(text):
+                if not c.isdigit():
+                    break
+
+            raise ValidationError(message='This entry accepts numbers only!', cursor_position=i)
+
+async def getInput(prompt:str="Instruction: ", input_suggestions:list=None, number_validator:bool=False):
     """
     Prompt for user input
     """
@@ -92,6 +109,8 @@ async def getInput(prompt:str="Instruction: ", input_suggestions:list=None):
         bottom_toolbar="[ENTER] submit [TAB] linebreak [Ctrl+N] new [Ctrl+Q] quit",
         completer=completer,
         key_bindings=bindings,
+        validator=NumberValidator() if number_validator else None,
+        default=str(config.max_steps) if number_validator else "",
     )
     print()
     return instruction.strip() if instruction else ""

{biblemate-0.0.22 → biblemate-0.0.24}/biblemate.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: biblemate
-Version: 0.0.22
+Version: 0.0.24
 Summary: BibleMate AI - Automate Your Bible Study
 Home-page: https://toolmate.ai
 Author: Eliran Wong

{biblemate-0.0.22 → biblemate-0.0.24}/biblemate.egg-info/requires.txt

@@ -1,6 +1,7 @@
 agentmake>=1.0.70
 agentmakemcp>=0.0.8
 alive-progress
+click
 fastmcp[cli]
 rich
 

{biblemate-0.0.22 → biblemate-0.0.24}/setup.py

@@ -27,7 +27,7 @@ with open(os.path.join(package, "requirements.txt"), "r") as fileObj:
 # https://packaging.python.org/en/latest/guides/distributing-packages-using-setuptools/
 setup(
     name=package,
-    version="0.0.22",
+    version="0.0.24",
     python_requires=">=3.8, <3.13",
     description=f"BibleMate AI - Automate Your Bible Study",
     long_description=long_description,

biblemate-0.0.22/biblemate/config.py

@@ -1 +0,0 @@
-agent_mode=True