biblemate 0.0.11__tar.gz

biblemate-0.0.11/PKG-INFO

@@ -0,0 +1,119 @@
+Metadata-Version: 2.1
+Name: biblemate
+Version: 0.0.11
+Summary: AgentMake AI MCP Servers - Easy setup of MCP servers running AgentMake AI agentic components.
+Home-page: https://toolmate.ai
+Author: Eliran Wong
+Author-email: support@toolmate.ai
+License: GNU General Public License (GPL)
+Project-URL: Source, https://github.com/eliranwong/xomateai
+Project-URL: Tracker, https://github.com/eliranwong/xomateai/issues
+Project-URL: Documentation, https://github.com/eliranwong/xomateai/wiki
+Project-URL: Funding, https://www.paypal.me/toolmate
+Keywords: mcp agent toolmate ai anthropic azure chatgpt cohere deepseek genai github googleai groq llamacpp mistral ollama openai vertexai xai
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Topic :: Utilities
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8, <3.13
+Provides-Extra: genai
+
+=========
+XoMate AI
+=========
+
+Execute. Orchestrate. Automate.
+
+**XoMate.AI is your autonomous execution engine—automating planning, orchestration, and execution of tasks using multiple tools to resolve user requests seamlessly.**
+
+For professionals, teams, and innovators who need more than just chat-based AI, xomate.ai is an intelligent automation agent that plans, coordinates, and executes tasks across multiple tools. Unlike basic AI chatbots, xomate.ai doesn’t just answer—it gets things done.
+
+Core Messaging
+--------------
+
+Elevator Pitch
+~~~~~~~~~~~~~~
+
+xomate.ai is an automation-first AI agent that takes your goals, creates a structured plan, and executes it by orchestrating multiple tools. It goes beyond conversation—delivering real results.
+
+Value Propositions
+~~~~~~~~~~~~~~~~~~
+
+*   **Execute**: Automatically carry out tasks from start to finish.
+*   **Orchestrate**: Seamlessly coordinate multiple tools and APIs.
+*   **Automate**: Save time and effort by letting xomate.ai handle complex workflows.
+
+Key Differentiators
+~~~~~~~~~~~~~~~~~~~
+
+*   Built on the `agentmake.ai <https://github.com/eliranwong/agentmake>`_ framework, proven through `LetMeDoIt.AI <https://github.com/eliranwong/letmedoit>`_, `ToolMate.AI <https://github.com/eliranwong/toolmate>`_ and `TeamGen AI <https://github.com/eliranwong/teamgenai>`_.
+*   Execution-focused, not just advisory.
+*   Flexible integration with existing tools and APIs.
+*   Scalable from individual users to enterprise workflows.
+*   **Versatile** – supports 16 AI backends and numerous models, leveraging the advantages of AgentMake AI.
+*   **Extensible** – capable of extending functionalities by interacting with Additional AgentMake AI tools or third-party MCP (Modal Context Protocol) servers.
+
+XoMate AI Agentic Workflow
+--------------------------
+
+1.  **XoMate AI** receives a request from a user.
+2.  **XoMate AI** analyzes the request and determines that it requires multiple steps to complete.
+3.  **XoMate AI** generates a ``Master Prompt`` that outlines the steps needed to complete the request.
+4.  **XoMate AI** sends the ``Master Prompt`` to a supervisor agent, who reviews the prompt and provides suggestions for improvement.
+5.  **XoMate AI** sends the suggestions to a tool selection agent, who selects the most appropriate tools for each step of the ``Master Prompt``.
+6.  **XoMate AI** sends the selected tools and the ``Master Prompt`` to an instruction generation agent, who converts the suggestions into clear and concise instructions for an AI assistant to follow.
+7.  **XoMate AI** sends the instructions to an AI assistant, who executes the instructions using the selected tools. When the selected tool is not an internal tool, built in with XoMate AI, XoMate AI calls the external tool via interacting with the MCP (Modal Context Protocol) servers, configured by users.
+8.  **XoMate AI** monitors the progress of the AI assistant and provides additional suggestions or instructions as needed.
+9.  Once all steps are completed, **XoMate AI** provides a concise summary of the results to the user.
+10. The user receives the final response, which fully resolves their original request.
+
+Development in Progress
+-----------------------
+
+1.  Agentic workflow developed and tested.
+2.  Core code built for the agentic workflow.
+3.  Tested with AgentMake AI MCP servers.
+
+Pending
+~~~~~~~
+
+*   Build an action plan agent to handle random requests.
+*   Refine code and improve effectiveness.
+*   Test with third-party systems.
+*   Select frequently used AgentMake AI tools to include in the main library as built-in tools.
+*   Build CLI/TUI interfaces.
+*   Build a web UI.
+*   Test on Windows, macOS, Linux, and ChromeOS.
+*   Test on Android mobile devices.
+
+Custom Features
+~~~~~~~~~~~~~~~
+
+*   options to unload some or all built-in tools
+*   custom XoMate AI system prompts
+*   edit master plan
+*   iteration allowance
+*   change tools
+
+... more ...
+
+Install (upcoming ...)
+----------------------
+
+.. code-block:: bash
+
+    pip install --upgrade xomateai
+
+Attention: The ``xomateai`` package is currently mirroring the ``agentmakemcp`` package. Once the development of XoMate AI reaches the production stage, the actual ``xomateai`` package will be uploaded.
+
+License
+-------
+
+This project is licensed under the MIT License - see the `LICENSE <LICENSE>`_ file for details.

biblemate-0.0.11/biblemate/README.md

@@ -0,0 +1,92 @@
+=========
+XoMate AI
+=========
+
+Execute. Orchestrate. Automate.
+
+**XoMate.AI is your autonomous execution engine—automating planning, orchestration, and execution of tasks using multiple tools to resolve user requests seamlessly.**
+
+For professionals, teams, and innovators who need more than just chat-based AI, xomate.ai is an intelligent automation agent that plans, coordinates, and executes tasks across multiple tools. Unlike basic AI chatbots, xomate.ai doesn’t just answer—it gets things done.
+
+Core Messaging
+--------------
+
+Elevator Pitch
+~~~~~~~~~~~~~~
+
+xomate.ai is an automation-first AI agent that takes your goals, creates a structured plan, and executes it by orchestrating multiple tools. It goes beyond conversation—delivering real results.
+
+Value Propositions
+~~~~~~~~~~~~~~~~~~
+
+*   **Execute**: Automatically carry out tasks from start to finish.
+*   **Orchestrate**: Seamlessly coordinate multiple tools and APIs.
+*   **Automate**: Save time and effort by letting xomate.ai handle complex workflows.
+
+Key Differentiators
+~~~~~~~~~~~~~~~~~~~
+
+*   Built on the `agentmake.ai <https://github.com/eliranwong/agentmake>`_ framework, proven through `LetMeDoIt.AI <https://github.com/eliranwong/letmedoit>`_, `ToolMate.AI <https://github.com/eliranwong/toolmate>`_ and `TeamGen AI <https://github.com/eliranwong/teamgenai>`_.
+*   Execution-focused, not just advisory.
+*   Flexible integration with existing tools and APIs.
+*   Scalable from individual users to enterprise workflows.
+*   **Versatile** – supports 16 AI backends and numerous models, leveraging the advantages of AgentMake AI.
+*   **Extensible** – capable of extending functionalities by interacting with Additional AgentMake AI tools or third-party MCP (Modal Context Protocol) servers.
+
+XoMate AI Agentic Workflow
+--------------------------
+
+1.  **XoMate AI** receives a request from a user.
+2.  **XoMate AI** analyzes the request and determines that it requires multiple steps to complete.
+3.  **XoMate AI** generates a ``Master Prompt`` that outlines the steps needed to complete the request.
+4.  **XoMate AI** sends the ``Master Prompt`` to a supervisor agent, who reviews the prompt and provides suggestions for improvement.
+5.  **XoMate AI** sends the suggestions to a tool selection agent, who selects the most appropriate tools for each step of the ``Master Prompt``.
+6.  **XoMate AI** sends the selected tools and the ``Master Prompt`` to an instruction generation agent, who converts the suggestions into clear and concise instructions for an AI assistant to follow.
+7.  **XoMate AI** sends the instructions to an AI assistant, who executes the instructions using the selected tools. When the selected tool is not an internal tool, built in with XoMate AI, XoMate AI calls the external tool via interacting with the MCP (Modal Context Protocol) servers, configured by users.
+8.  **XoMate AI** monitors the progress of the AI assistant and provides additional suggestions or instructions as needed.
+9.  Once all steps are completed, **XoMate AI** provides a concise summary of the results to the user.
+10. The user receives the final response, which fully resolves their original request.
+
+Development in Progress
+-----------------------
+
+1.  Agentic workflow developed and tested.
+2.  Core code built for the agentic workflow.
+3.  Tested with AgentMake AI MCP servers.
+
+Pending
+~~~~~~~
+
+*   Build an action plan agent to handle random requests.
+*   Refine code and improve effectiveness.
+*   Test with third-party systems.
+*   Select frequently used AgentMake AI tools to include in the main library as built-in tools.
+*   Build CLI/TUI interfaces.
+*   Build a web UI.
+*   Test on Windows, macOS, Linux, and ChromeOS.
+*   Test on Android mobile devices.
+
+Custom Features
+~~~~~~~~~~~~~~~
+
+*   options to unload some or all built-in tools
+*   custom XoMate AI system prompts
+*   edit master plan
+*   iteration allowance
+*   change tools
+
+... more ...
+
+Install (upcoming ...)
+----------------------
+
+.. code-block:: bash
+
+    pip install --upgrade xomateai
+
+Attention: The ``xomateai`` package is currently mirroring the ``agentmakemcp`` package. Once the development of XoMate AI reaches the production stage, the actual ``xomateai`` package will be uploaded.
+
+License
+-------
+
+This project is licensed under the MIT License - see the `LICENSE <LICENSE>`_ file for details.

biblemate-0.0.11/biblemate/core/systems.py

@@ -0,0 +1,26 @@
+import os
+from agentmake import PACKAGE_PATH, AGENTMAKE_USER_DIR, readTextFile
+
+def get_system_suggestion(master_plan: str) -> str:
+    """
+    create system prompt for suggestion
+    """
+    possible_system_file_path_2 = os.path.join(PACKAGE_PATH, "systems", "xomate", "supervisor.md")
+    possible_system_file_path_1 = os.path.join(AGENTMAKE_USER_DIR, "systems", "xomate", "supervisor.md")
+    return readTextFile(possible_system_file_path_2 if os.path.isfile(possible_system_file_path_2) else possible_system_file_path_1).format(master_plan=master_plan)
+
+def get_system_tool_instruction(tool: str, tool_description: str = "") -> str:
+    """
+    create system prompt for tool instruction
+    """
+    possible_system_file_path_2 = os.path.join(PACKAGE_PATH, "systems", "xomate", "tool_instruction.md")
+    possible_system_file_path_1 = os.path.join(AGENTMAKE_USER_DIR, "systems", "xomate", "tool_instruction.md")
+    return readTextFile(possible_system_file_path_2 if os.path.isfile(possible_system_file_path_2) else possible_system_file_path_1).format(tool=tool, tool_description=tool_description)
+
+def get_system_tool_selection(available_tools: list, tool_descriptions: str) -> str:
+    """
+    create system prompt for tool selection
+    """
+    possible_system_file_path_2 = os.path.join(PACKAGE_PATH, "systems", "xomate", "tool_selection.md")
+    possible_system_file_path_1 = os.path.join(AGENTMAKE_USER_DIR, "systems", "xomate", "tool_selection.md")
+    return readTextFile(possible_system_file_path_2 if os.path.isfile(possible_system_file_path_2) else possible_system_file_path_1).format(available_tools=available_tools, tool_descriptions=tool_descriptions)

biblemate-0.0.11/biblemate/main.py

@@ -0,0 +1,288 @@
+from biblemate.core.systems import *
+from biblemate.ui.prompts import getInput
+from biblemate.ui.info import get_banner
+from pathlib import Path
+import asyncio, re, os
+from alive_progress import alive_bar
+from fastmcp import Client
+from agentmake import agentmake, writeTextFile, getCurrentDateTime, AGENTMAKE_USER_DIR, USER_OS, DEVELOPER_MODE
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.terminal_theme import MONOKAI
+if not USER_OS == "Windows":
+    import readline  # for better input experience
+
+# MCP server client example
+# testing in progress; not in production yet
+client = Client("http://127.0.0.1:8083/mcp/") # !agentmakemcp agentmakemcp/examples/bible_study.py
+
+# TODO: allow overriding default AgentMake config
+AGENTMAKE_CONFIG = {
+    "backend": None,
+    "model": None,
+    "model_keep_alive": None,
+    "temperature": None,
+    "max_tokens": None,
+    "context_window": None,
+    "batch_size": None,
+    "stream": None,
+    "print_on_terminal": False,
+    "word_wrap": False,
+}
+MAX_STEPS = 50
+
+async def main():
+
+    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}
+
+        available_tools = list(tools.keys())
+        if not "get_direct_text_response" in available_tools:
+            available_tools.insert(0, "get_direct_text_response")
+
+        # 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}) """
+
+        user_request = ""
+        messages = []
+
+        while not user_request == ".quit":
+
+            # spinner while thinking
+            async def thinking(process):
+                with Progress(
+                    SpinnerColumn(),
+                    TextColumn("[progress.description]{task.description}"),
+                    transient=True  # This makes the progress bar disappear after the task is done
+                ) as progress:
+                    # Add an indefinite task (total=None)
+                    task_id = progress.add_task("Thinking ...", total=None)
+                    # Create and run the async task concurrently
+                    async_task = asyncio.create_task(process())
+                    # Loop until the async task is done
+                    while not async_task.done():
+                        progress.update(task_id)
+                        await asyncio.sleep(0.01)
+                await async_task
+            # progress bar for processing steps
+            async def async_alive_bar(task):
+                """
+                A coroutine that runs a progress bar while awaiting a task.
+                """
+                with alive_bar(title="Processing...", spinner='dots') as bar:
+                    while not task.done():
+                        bar() # Update the bar
+                        await asyncio.sleep(0.01) # Yield control back to the event loop
+                return task.result()
+            async def process_step_async(step_number):
+                """
+                Manages the async task and the progress bar.
+                """
+                print(f"# Starting Step [{step_number}]...")
+                # Create the async task but don't await it yet.
+                task = asyncio.create_task(process_step())
+                # Await the custom async progress bar that awaits the task.
+                await async_alive_bar(task)
+
+            if messages:
+                console.rule()
+
+            # 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: :")
+            input_suggestions = [".new", ".quit"]+prompt_list
+            user_request = await getInput("> ", input_suggestions)
+            while not user_request.strip():
+                user_request = await getInput("> ", input_suggestions)
+            # TODO: auto-prompt engineering based on the user request
+
+            if user_request in (".new", ".quit"):
+                # TODO: backup messages
+                if user_request == ".new":
+                    user_request = ""
+                    messages = []
+                    console.clear()
+                    console.print(get_banner())
+                continue
+
+            print(prompt_pattern, user_request)
+            if re.search(prompt_pattern, user_request):
+                print(111)
+                prompt_name = re.search(prompt_pattern, user_request).group(1)
+                user_request = user_request[len(prompt_name):]
+                # Call the MCP prompt
+                result = await client.get_prompt(prompt_name[1:], {"request": user_request})
+                #print(result, "\n\n")
+                master_plan = result.messages[0].content.text
+                # display info
+                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")
+                # Generate master plan
+                master_plan = ""
+                async def generate_master_plan():
+                    nonlocal master_plan
+                    # Create initial prompt to create master plan
+                    initial_prompt = f"""Provide me with the `Preliminary Action Plan` and the `Measurable Outcome` for resolving `My Request`.
+    
+# Available Tools
+
+Available tools are: {available_tools}.
+
+{tool_descriptions}
+
+# My Request
+
+{user_request}"""
+                    console.print(Markdown("# Master plan"), "\n")
+                    print()
+                    master_plan = agentmake(messages+[{"role": "user", "content": initial_prompt}], system="create_action_plan", **AGENTMAKE_CONFIG)[-1].get("content", "").strip()
+                await thinking(generate_master_plan)
+                # display info
+                console.print(Markdown(master_plan), "\n\n")
+
+            system_suggestion = get_system_suggestion(master_plan)
+
+            # Tool selection systemm message
+            system_tool_selection = get_system_tool_selection(available_tools, tool_descriptions)
+
+            # Get the first suggestion
+            next_suggestion = ""
+            async def get_first_suggestion():
+                nonlocal next_suggestion
+                console.print(Markdown("## Suggestion [1]"), "\n")
+                next_suggestion = agentmake(user_request, system=system_suggestion, **AGENTMAKE_CONFIG)[-1].get("content", "").strip()
+            await thinking(get_first_suggestion)
+            console.print(Markdown(next_suggestion), "\n\n")
+
+            if not messages:
+                messages = [
+                    {"role": "system", "content": "You are XoMate, an autonomous AI agent."},
+                    {"role": "user", "content": user_request},
+                ]
+            else:
+                messages.append({"role": "user", "content": user_request})
+
+            step = 1
+            while not ("DONE" in next_suggestion or re.sub("^[^A-Za-z]*?([A-Za-z]+?)[^A-Za-z]*?$", r"\1", next_suggestion).upper() == "DONE"):
+
+                # Get tool suggestion for the next iteration
+                suggested_tools = []
+                async def get_tool_suggestion():
+                    nonlocal suggested_tools, next_suggestion, system_tool_selection
+                    if DEVELOPER_MODE:
+                        console.print(Markdown(f"## Tool Selection (descending order by relevance) [{step}]"), "\n")
+                    else:
+                        console.print(Markdown(f"## Tool Selection [{step}]"), "\n")
+                    # Extract suggested tools from the step suggestion
+                    suggested_tools = agentmake(next_suggestion, system=system_tool_selection, **AGENTMAKE_CONFIG)[-1].get("content", "").strip() # Note: suggested tools are printed on terminal by default, could be hidden by setting `print_on_terminal` to false
+                    suggested_tools = re.sub(r"^.*?(\[.*?\]).*?$", r"\1", suggested_tools, flags=re.DOTALL)
+                    suggested_tools = eval(suggested_tools) if suggested_tools.startswith("[") and suggested_tools.endswith("]") else ["get_direct_text_response"] # fallback to direct response
+                await thinking(get_tool_suggestion)
+                if DEVELOPER_MODE:
+                    console.print(Markdown(str(suggested_tools)))
+
+                # Use the next suggested tool
+                next_tool = suggested_tools[0] if suggested_tools else "get_direct_text_response"
+                prefix = f"## Next Tool [{step}]\n\n" if DEVELOPER_MODE else ""
+                console.print(Markdown(f"{prefix}`{next_tool}`"))
+                print()
+
+                # Get next step instruction
+                next_step = ""
+                async def get_next_step():
+                    nonlocal next_step, next_tool, next_suggestion, tools
+                    console.print(Markdown(f"## Next Instruction [{step}]"), "\n")
+                    if next_tool == "get_direct_text_response":
+                        next_step = agentmake(next_suggestion, system="xomate/direct_instruction", **AGENTMAKE_CONFIG)[-1].get("content", "").strip()
+                    else:
+                        next_tool_description = tools.get(next_tool, "No description available.")
+                        system_tool_instruction = get_system_tool_instruction(next_tool, next_tool_description)
+                        next_step = agentmake(next_suggestion, system=system_tool_instruction, **AGENTMAKE_CONFIG)[-1].get("content", "").strip()
+                await thinking(get_next_step)
+                console.print(Markdown(next_step), "\n\n")
+
+                if messages[-1]["role"] != "assistant": # first iteration
+                    messages.append({"role": "assistant", "content": "Please provide me with an initial instruction to begin."})
+                messages.append({"role": "user", "content": next_step})
+
+                async def process_step():
+                    nonlocal messages, next_tool, next_step
+                    if next_tool == "get_direct_text_response":
+                        messages = agentmake(messages, system="auto", **AGENTMAKE_CONFIG)
+                    else:
+                        try:
+                            tool_result = await client.call_tool(next_tool, {"request": next_step})
+                            tool_result = tool_result.content[0].text
+                            messages[-1]["content"] += f"\n\n[Using tool `{next_tool}`]"
+                            messages.append({"role": "assistant", "content": tool_result})
+                        except Exception as e:
+                            if DEVELOPER_MODE:
+                                console.print(f"Error: {e}\nFallback to direct response...\n\n")
+                            messages = agentmake(messages, system="auto", **AGENTMAKE_CONFIG)
+                await process_step_async(step)
+
+                console.print(Markdown(f"\n## Output [{step}]\n\n{messages[-1]["content"]}"))
+
+                # 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!")
+                    break
+
+                # Get the next suggestion
+                async def get_next_suggestion():
+                    nonlocal next_suggestion, messages, system_suggestion
+                    console.print(Markdown(f"## Suggestion [{step}]"), "\n")
+                    next_suggestion = agentmake(messages, system=system_suggestion, follow_up_prompt="Please provide me with the next suggestion.", **AGENTMAKE_CONFIG)[-1].get("content", "").strip()
+                await thinking(get_next_suggestion)
+                #print()
+                console.print(Markdown(next_suggestion), "\n")
+
+            # Backup
+            timestamp = getCurrentDateTime()
+            storagePath = os.path.join(AGENTMAKE_USER_DIR, "xomate", 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 text
+            console.save_text(os.path.join(storagePath, "conversation.md"))
+            # Inform users of the backup location
+            print(f"Conversation backup saved to {storagePath}")
+            print(f"HTML file saved to {html_file}\n")
+
+asyncio.run(main())

biblemate-0.0.11/biblemate/package_name.txt

@@ -0,0 +1 @@
+biblemate

biblemate-0.0.11/biblemate/requirements.txt

@@ -0,0 +1,5 @@
+agentmake>=1.0.63
+agentmakemcp>=0.0.8
+fastmcp
+rich
+alive-progress

biblemate-0.0.11/biblemate/ui/info.py

@@ -0,0 +1,26 @@
+from rich.panel import Panel
+from rich.text import Text
+from rich.align import Align
+
+# Project title styling
+def get_banner():
+    # Title styling
+    title = Text("XoMate AI", style="bold magenta", justify="center")
+    title.stylize("bold magenta underline", 0, len("XoMate AI"))
+    # Tagline styling
+    tagline = Text("Execute. Orchestrate. Automate.", style="bold cyan", justify="center")
+    # Combine into a panel
+    banner_content = Align.center(
+        Text("\n") + title + Text("\n") + tagline + Text("\n"),
+        vertical="middle"
+    )
+    banner = Panel(
+        banner_content,
+        border_style="bright_blue",
+        title="🚀 Gets Things Done",
+        title_align="left",
+        subtitle="Eliran Wong",
+        subtitle_align="right",
+        padding=(1, 4)
+    )
+    return banner

biblemate-0.0.11/biblemate/ui/prompts.py

@@ -0,0 +1,97 @@
+from agentmake.main import AGENTMAKE_USER_DIR
+from agentmake.utils.system import getCliOutput
+import os, shutil
+
+
+async def getInput(prompt:str="Instruction: ", input_suggestions:list=None):
+    """
+    Prompt for user input
+    """
+    # place import lines here to work with stdin
+    from prompt_toolkit import PromptSession
+    from prompt_toolkit.history import FileHistory
+    from prompt_toolkit.completion import WordCompleter, FuzzyCompleter
+    from prompt_toolkit.key_binding import KeyBindings
+    bindings = KeyBindings()
+    # new chat
+    @bindings.add("c-n")
+    def _(event):
+        buffer = event.app.current_buffer
+        buffer.text = ".new"
+        buffer.validate_and_handle()
+    # quit
+    @bindings.add("c-q")
+    def _(event):
+        buffer = event.app.current_buffer
+        buffer.text = ".quit"
+        buffer.validate_and_handle()
+    # copy text to clipboard
+    @bindings.add("c-c")
+    def _(event):
+        try:
+            buffer = event.app.current_buffer
+            data = buffer.copy_selection()
+            copyText = data.text
+            if shutil.which("termux-clipboard-set"):
+                from pydoc import pipepager
+                pipepager(copyText, cmd="termux-clipboard-set")
+            else:
+                import pyperclip
+                pyperclip.copy(copyText)
+        except:
+            pass
+    # paste clipboard text
+    @bindings.add("c-v")
+    def _(event):
+        try:
+            import pyperclip
+            buffer = event.app.current_buffer
+            buffer.cut_selection()
+            clipboardText = getCliOutput("termux-clipboard-get") if shutil.which("termux-clipboard-get") else pyperclip.paste()
+            buffer.insert_text(clipboardText)
+        except:
+            pass
+    # insert new line
+    @bindings.add("c-i")
+    def _(event):
+        event.app.current_buffer.newline()
+    # reset buffer
+    @bindings.add("c-z")
+    def _(event):
+        event.app.current_buffer.reset()
+    # go to the beginning of the text
+    @bindings.add("escape", "a")
+    def _(event):
+        event.app.current_buffer.cursor_position = 0
+    # go to the end of the text
+    @bindings.add("escape", "z")
+    def _(event):
+        buffer = event.app.current_buffer
+        buffer.cursor_position = len(buffer.text)
+    # go to current line starting position
+    @bindings.add("home")
+    @bindings.add("escape", "b")
+    def _(event):
+        buffer = event.app.current_buffer
+        buffer.cursor_position = buffer.cursor_position - buffer.document.cursor_position_col
+    # go to current line ending position
+    @bindings.add("end")
+    @bindings.add("escape", "e")
+    def _(event):
+        buffer = event.app.current_buffer
+        buffer.cursor_position = buffer.cursor_position + buffer.document.get_end_of_line_position()
+
+    history_dir = os.path.join(AGENTMAKE_USER_DIR, "history")
+    if not os.path.isdir(history_dir):
+        from pathlib import Path
+        Path(history_dir).mkdir(parents=True, exist_ok=True)
+    session = PromptSession(history=FileHistory(os.path.join(history_dir, "xomate_history")))
+    completer = FuzzyCompleter(WordCompleter(input_suggestions, ignore_case=True)) if input_suggestions else None
+    instruction = await session.prompt_async(
+        prompt,
+        bottom_toolbar="[ENTER] submit [TAB] new line [Ctrl+N] new chat [Ctrl+Q] quit",
+        completer=completer,
+        key_bindings=bindings,
+    )
+    print()
+    return instruction.strip() if instruction else ""

biblemate-0.0.11/biblemate.egg-info/PKG-INFO

@@ -0,0 +1,119 @@
+Metadata-Version: 2.1
+Name: biblemate
+Version: 0.0.11
+Summary: AgentMake AI MCP Servers - Easy setup of MCP servers running AgentMake AI agentic components.
+Home-page: https://toolmate.ai
+Author: Eliran Wong
+Author-email: support@toolmate.ai
+License: GNU General Public License (GPL)
+Project-URL: Source, https://github.com/eliranwong/xomateai
+Project-URL: Tracker, https://github.com/eliranwong/xomateai/issues
+Project-URL: Documentation, https://github.com/eliranwong/xomateai/wiki
+Project-URL: Funding, https://www.paypal.me/toolmate
+Keywords: mcp agent toolmate ai anthropic azure chatgpt cohere deepseek genai github googleai groq llamacpp mistral ollama openai vertexai xai
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Topic :: Utilities
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8, <3.13
+Provides-Extra: genai
+
+=========
+XoMate AI
+=========
+
+Execute. Orchestrate. Automate.
+
+**XoMate.AI is your autonomous execution engine—automating planning, orchestration, and execution of tasks using multiple tools to resolve user requests seamlessly.**
+
+For professionals, teams, and innovators who need more than just chat-based AI, xomate.ai is an intelligent automation agent that plans, coordinates, and executes tasks across multiple tools. Unlike basic AI chatbots, xomate.ai doesn’t just answer—it gets things done.
+
+Core Messaging
+--------------
+
+Elevator Pitch
+~~~~~~~~~~~~~~
+
+xomate.ai is an automation-first AI agent that takes your goals, creates a structured plan, and executes it by orchestrating multiple tools. It goes beyond conversation—delivering real results.
+
+Value Propositions
+~~~~~~~~~~~~~~~~~~
+
+*   **Execute**: Automatically carry out tasks from start to finish.
+*   **Orchestrate**: Seamlessly coordinate multiple tools and APIs.
+*   **Automate**: Save time and effort by letting xomate.ai handle complex workflows.
+
+Key Differentiators
+~~~~~~~~~~~~~~~~~~~
+
+*   Built on the `agentmake.ai <https://github.com/eliranwong/agentmake>`_ framework, proven through `LetMeDoIt.AI <https://github.com/eliranwong/letmedoit>`_, `ToolMate.AI <https://github.com/eliranwong/toolmate>`_ and `TeamGen AI <https://github.com/eliranwong/teamgenai>`_.
+*   Execution-focused, not just advisory.
+*   Flexible integration with existing tools and APIs.
+*   Scalable from individual users to enterprise workflows.
+*   **Versatile** – supports 16 AI backends and numerous models, leveraging the advantages of AgentMake AI.
+*   **Extensible** – capable of extending functionalities by interacting with Additional AgentMake AI tools or third-party MCP (Modal Context Protocol) servers.
+
+XoMate AI Agentic Workflow
+--------------------------
+
+1.  **XoMate AI** receives a request from a user.
+2.  **XoMate AI** analyzes the request and determines that it requires multiple steps to complete.
+3.  **XoMate AI** generates a ``Master Prompt`` that outlines the steps needed to complete the request.
+4.  **XoMate AI** sends the ``Master Prompt`` to a supervisor agent, who reviews the prompt and provides suggestions for improvement.
+5.  **XoMate AI** sends the suggestions to a tool selection agent, who selects the most appropriate tools for each step of the ``Master Prompt``.
+6.  **XoMate AI** sends the selected tools and the ``Master Prompt`` to an instruction generation agent, who converts the suggestions into clear and concise instructions for an AI assistant to follow.
+7.  **XoMate AI** sends the instructions to an AI assistant, who executes the instructions using the selected tools. When the selected tool is not an internal tool, built in with XoMate AI, XoMate AI calls the external tool via interacting with the MCP (Modal Context Protocol) servers, configured by users.
+8.  **XoMate AI** monitors the progress of the AI assistant and provides additional suggestions or instructions as needed.
+9.  Once all steps are completed, **XoMate AI** provides a concise summary of the results to the user.
+10. The user receives the final response, which fully resolves their original request.
+
+Development in Progress
+-----------------------
+
+1.  Agentic workflow developed and tested.
+2.  Core code built for the agentic workflow.
+3.  Tested with AgentMake AI MCP servers.
+
+Pending
+~~~~~~~
+
+*   Build an action plan agent to handle random requests.
+*   Refine code and improve effectiveness.
+*   Test with third-party systems.
+*   Select frequently used AgentMake AI tools to include in the main library as built-in tools.
+*   Build CLI/TUI interfaces.
+*   Build a web UI.
+*   Test on Windows, macOS, Linux, and ChromeOS.
+*   Test on Android mobile devices.
+
+Custom Features
+~~~~~~~~~~~~~~~
+
+*   options to unload some or all built-in tools
+*   custom XoMate AI system prompts
+*   edit master plan
+*   iteration allowance
+*   change tools
+
+... more ...
+
+Install (upcoming ...)
+----------------------
+
+.. code-block:: bash
+
+    pip install --upgrade xomateai
+
+Attention: The ``xomateai`` package is currently mirroring the ``agentmakemcp`` package. Once the development of XoMate AI reaches the production stage, the actual ``xomateai`` package will be uploaded.
+
+License
+-------
+
+This project is licensed under the MIT License - see the `LICENSE <LICENSE>`_ file for details.

biblemate-0.0.11/biblemate.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+setup.py
+biblemate/README.md
+biblemate/__init__.py
+biblemate/main.py
+biblemate/package_name.txt
+biblemate/requirements.txt
+biblemate.egg-info/PKG-INFO
+biblemate.egg-info/SOURCES.txt
+biblemate.egg-info/dependency_links.txt
+biblemate.egg-info/entry_points.txt
+biblemate.egg-info/requires.txt
+biblemate.egg-info/top_level.txt
+biblemate/core/systems.py
+biblemate/ui/info.py
+biblemate/ui/prompts.py

biblemate-0.0.11/biblemate.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

biblemate-0.0.11/biblemate.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+biblemate = biblemate.main:main

biblemate-0.0.11/biblemate.egg-info/requires.txt

@@ -0,0 +1,8 @@
+agentmake>=1.0.63
+agentmakemcp>=0.0.8
+alive-progress
+fastmcp
+rich
+
+[genai]
+google-genai>=1.25.0

biblemate-0.0.11/biblemate.egg-info/top_level.txt

@@ -0,0 +1 @@
+biblemate

biblemate-0.0.11/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

biblemate-0.0.11/setup.py

@@ -0,0 +1,90 @@
+from setuptools import setup
+from setuptools.command.install import install
+import os, shutil, platform, sys
+
+# package name
+package_name_0 = "package_name.txt"
+with open(package_name_0, "r", encoding="utf-8") as fileObj:
+    package = fileObj.read()
+package_name_1 = os.path.join(package, "package_name.txt") # package readme
+shutil.copy(package_name_0, package_name_1)
+
+# update package readme
+latest_readme = os.path.join("..", "README_pypi.md") # github repository readme
+package_readme = os.path.join(package, "README.md") # package readme
+shutil.copy(latest_readme, package_readme)
+with open(package_readme, "r", encoding="utf-8") as fileObj:
+    long_description = fileObj.read()
+
+# get required packages
+install_requires = []
+with open(os.path.join(package, "requirements.txt"), "r") as fileObj:
+    for line in fileObj.readlines():
+        mod = line.strip()
+        if mod:
+            install_requires.append(mod)
+
+# https://packaging.python.org/en/latest/guides/distributing-packages-using-setuptools/
+setup(
+    name=package,
+    version="0.0.11",
+    python_requires=">=3.8, <3.13",
+    description=f"AgentMake AI MCP Servers - Easy setup of MCP servers running AgentMake AI agentic components.",
+    long_description=long_description,
+    author="Eliran Wong",
+    author_email="support@toolmate.ai",
+    packages=[
+        package,
+        f"{package}.core",
+        f"{package}.ui",
+    ],
+    package_data={
+        package: ["*.*"],
+        f"{package}.core": ["*.*"],
+        f"{package}.ui": ["*.*"],
+    },
+    license="GNU General Public License (GPL)",
+    install_requires=install_requires,
+    extras_require={
+        'genai': ["google-genai>=1.25.0"],  # Dependencies for running Vertex AI
+    },
+    entry_points={
+        "console_scripts": [
+            f"{package}={package}.main:main",
+        ],
+    },
+    keywords="mcp agent toolmate ai anthropic azure chatgpt cohere deepseek genai github googleai groq llamacpp mistral ollama openai vertexai xai",
+    url="https://toolmate.ai",
+    project_urls={
+        "Source": "https://github.com/eliranwong/xomateai",
+        "Tracker": "https://github.com/eliranwong/xomateai/issues",
+        "Documentation": "https://github.com/eliranwong/xomateai/wiki",
+        "Funding": "https://www.paypal.me/toolmate",
+    },
+    classifiers=[
+        # Reference: https://pypi.org/classifiers/
+
+        # How mature is this project? Common values are
+        #   3 - Alpha
+        #   4 - Beta
+        #   5 - Production/Stable
+        'Development Status :: 5 - Production/Stable',
+
+        # Indicate who your project is intended for
+        'Intended Audience :: End Users/Desktop',
+        'Topic :: Utilities',
+        'Topic :: Scientific/Engineering :: Artificial Intelligence',
+        'Topic :: Software Development :: Build Tools',
+
+        # Pick your license as you wish (should match "license" above)
+        'License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)',
+
+        # Specify the Python versions you support here. In particular, ensure
+        # that you indicate whether you support Python 2, Python 3 or both.
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
+        'Programming Language :: Python :: 3.12',
+    ],
+)