lollms-client 0.22.0__py3-none-any.whl → 0.24.0__py3-none-any.whl

examples/console_discussion/console_app.py

@@ -0,0 +1,266 @@
+import os
+import shutil
+import subprocess
+import sys
+import json
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+# Correctly import all necessary classes from the lollms_client package
+from lollms_client import LollmsClient, LollmsDataManager, LollmsDiscussion, LollmsPersonality
+from ascii_colors import ASCIIColors, trace_exception
+
+# --- Configuration ---
+MAX_CONTEXT_SIZE_FOR_TEST = 2048 # Increased for agentic turns
+
+# Database and workspace configuration
+WORKSPACE_DIR = Path("./test_workspace_agentic")
+DATABASE_PATH = f"sqlite:///{WORKSPACE_DIR / 'test_discussion_agentic.db'}"
+DISCUSSION_ID = "console-agentic-test-1" # Use a fixed ID for easy resumption
+
+# --- MOCK KNOWLEDGE BASE for RAG ---
+MOCK_KNOWLEDGE_BASE = {
+    "python_basics.md": [
+        {"chunk_id": 1, "text": "Python is a high-level, interpreted programming language known for its readability. It was created by Guido van Rossum and released in 1991."},
+        {"chunk_id": 2, "text": "Key features of Python include dynamic typing, garbage collection, and a large standard library. It supports procedural, object-oriented, and functional programming."},
+    ],
+    "javascript_info.js": [
+        {"chunk_id": 1, "text": "JavaScript is a scripting language for front-end web development. It is also used in back-end development (Node.js)."},
+        {"chunk_id": 2, "text": "Popular JavaScript frameworks include React, Angular, and Vue.js."},
+    ],
+    "ai_concepts.txt": [
+        {"chunk_id": 1, "text": "Retrieval Augmented Generation (RAG) is an AI framework for improving LLM responses by grounding the model on external knowledge sources."},
+    ]
+}
+
+# --- Dummy MCP Server Scripts ---
+TIME_SERVER_PY = """
+import asyncio
+from datetime import datetime
+from mcp.server.fastmcp import FastMCP
+mcp_server = FastMCP("TimeMCP", description="A server that provides the current time.", host="localhost",
+            port=9624,
+            log_level="DEBUG")
+@mcp_server.tool()
+def get_current_time(user_id: str = "unknown"):
+    return {"time": datetime.now().isoformat(), "user_id": user_id}
+if __name__ == "__main__": mcp_server.run(transport="streamable-http")
+"""
+CALCULATOR_SERVER_PY = """
+import asyncio
+from typing import List, Union
+from mcp.server.fastmcp import FastMCP
+mcp_server = FastMCP("TimeMCP", description="A server that provides the current time.", host="localhost",
+            port=9625,
+            log_level="DEBUG")
+@mcp_server.tool()
+def add_numbers(numbers: List[Union[int, float]]):
+    if not isinstance(numbers, list): return {"error": "Input must be a list"}
+    return {"sum": sum(numbers)}
+if __name__ == "__main__": mcp_server.run(transport="streamable-http")
+"""
+
+# --- RAG Mock Function ---
+def mock_rag_query_function(query_text: str, top_k: int = 3, **kwargs) -> List[Dict[str, Any]]:
+    ASCIIColors.magenta(f"\n  [MOCK RAG] Querying knowledge base for: '{query_text}'")
+    results = []
+    query_lower = query_text.lower()
+    for file_path, chunks in MOCK_KNOWLEDGE_BASE.items():
+        for chunk in chunks:
+            if any(word in chunk["text"].lower() for word in query_lower.split() if len(word) > 2):
+                results.append({"file_path": file_path, "chunk_text": chunk["text"]})
+    ASCIIColors.magenta(f"  [MOCK RAG] Found {len(results[:top_k])} relevant chunks.")
+    return results[:top_k]
+
+def start_mcp_servers():
+    """Starts the dummy MCP servers in the background."""
+    ASCIIColors.yellow("--- Starting background MCP servers ---")
+    server_dir = WORKSPACE_DIR / "mcp_servers"
+    server_dir.mkdir(exist_ok=True, parents=True)
+    
+    (server_dir / "time_server.py").write_text(TIME_SERVER_PY)
+    (server_dir / "calculator_server.py").write_text(CALCULATOR_SERVER_PY)
+
+    procs = []
+    procs.append(subprocess.Popen([sys.executable, str(server_dir / "time_server.py")], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL))
+    procs.append(subprocess.Popen([sys.executable, str(server_dir / "calculator_server.py")], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL))
+    ASCIIColors.yellow("--- MCP servers launched ---")
+    return procs
+
+def setup_client_and_discussion() -> LollmsDiscussion:
+    """Sets up the LollmsClient with MCP, the DB manager, and the discussion."""
+    print("--- Setting up Lollms Environment ---")
+    WORKSPACE_DIR.mkdir(exist_ok=True)
+
+    mcp_config = {
+        "servers_infos": {
+            "time_machine": {"server_url": "http://localhost:9624/mcp"},
+            "calc_unit": {"server_url": "http://localhost:9625/mcp"},
+        }
+    }
+
+    try:
+        client = LollmsClient(
+            "ollama",
+            model_name="mistral-nemo:latest",
+            mcp_binding_name="remote_mcp",
+            mcp_binding_config=mcp_config
+        )
+    except Exception as e:
+        trace_exception(e)
+        print("\n---FATAL ERROR---")
+        print("Could not initialize LollmsClient. Ensure Ollama is running and mcp is installed.")
+        exit()
+
+    print(f"-> Using model: {client.binding.model_name}")
+    print(f"-> Using MCP binding: {client.mcp.binding_name}")
+
+    db_manager = LollmsDataManager(db_path=DATABASE_PATH)
+    discussion = db_manager.get_discussion(client, DISCUSSION_ID)
+    
+    if discussion:
+        print(f"-> Resuming discussion (ID: {DISCUSSION_ID})")
+        discussion.max_context_size = MAX_CONTEXT_SIZE_FOR_TEST
+    else:
+        print(f"-> Creating new discussion (ID: {DISCUSSION_ID})")
+        discussion = LollmsDiscussion.create_new(
+            lollms_client=client,
+            db_manager=db_manager,
+            id=DISCUSSION_ID,
+            title="Console Agentic Test",
+            max_context_size=MAX_CONTEXT_SIZE_FOR_TEST
+        )
+
+    print("--- Setup Complete. Ready to chat! ---\n")
+    return discussion
+
+def print_help():
+    print("\n--- Commands ---")
+    print("!agent <prompt>  - Run a prompt using all available tools (MCP).")
+    print("!rag <prompt>    - Run a prompt using the mock knowledge base (RAG).")
+    print("!both <prompt>   - Run a prompt using both MCP tools and RAG.")
+    print("!status          - Show current discussion state (pruning, message count).")
+    print("!regen           - Regenerate the last AI response.")
+    print("!exit            - Exit the application.")
+    print("----------------\n")
+
+def print_agentic_results(response_dict):
+    """Renders a beautiful report of the agent's turn."""
+    ai_message = response_dict.get('ai_message')
+    if not ai_message:
+        return
+
+    ASCIIColors.cyan("\n" + "="*22 + " Agentic Turn Report " + "="*22)
+
+    # --- Final Answer ---
+    ASCIIColors.blue("\nFinal Answer:")
+    ASCIIColors.green(f"  {ai_message.content}")
+
+    # --- Agent's Internal Monologue (The Scratchpad) ---
+    if ai_message.scratchpad:
+        ASCIIColors.blue("\nAgent's Reasoning Log (Scratchpad):")
+        # Print scratchpad line by line for better color coding
+        for line in ai_message.scratchpad.split('\n'):
+            if line.startswith("### Step"):
+                ASCIIColors.yellow(line)
+            elif line.startswith("- **Action**:") or line.startswith("- **Result**:") or line.startswith("- **Error**:") :
+                ASCIIColors.magenta(line)
+            else:
+                print(line)
+
+    # --- Sources Used (from metadata) ---
+    if ai_message.metadata and "sources" in ai_message.metadata:
+        sources = ai_message.metadata.get("sources", [])
+        if sources:
+            ASCIIColors.blue("\nSources Consulted (RAG):")
+            for i, source in enumerate(sources):
+                print(f"  [{i+1}] Path: {source.get('file_path', 'N/A')}")
+                # Indent the content for readability
+                content = source.get('chunk_text', 'N/A').replace('\n', '\n      ')
+                print(f"      Content: \"{content}\"")
+    
+    ASCIIColors.cyan("\n" + "="*61 + "\n")
+
+def run_chat_console(discussion: LollmsDiscussion):
+    print_help()
+    while True:
+        user_input = input("You: ")
+        if not user_input:
+            continue
+
+        use_mcps_flag = False
+        use_data_store_flag = False
+        prompt = user_input
+
+        # --- Command Handling ---
+        if user_input.lower().startswith("!exit"):
+            break
+        elif user_input.lower().startswith("!help"):
+            print_help()
+            continue
+        elif user_input.lower().startswith("!status"):
+            # Assuming a print_status function exists
+            # print_status(discussion)
+            continue
+        elif user_input.lower().startswith("!regen"):
+            # Assuming a regenerate_branch method exists
+            # discussion.regenerate_branch(...)
+            continue
+        elif user_input.lower().startswith("!agent "):
+            use_mcps_flag = True
+            prompt = user_input[7:].strip()
+            ASCIIColors.yellow(f"Agentic MCP turn initiated for: '{prompt}'")
+        elif user_input.lower().startswith("!rag "):
+            use_data_store_flag = True
+            prompt = user_input[5:].strip()
+            ASCIIColors.yellow(f"Agentic RAG turn initiated for: '{prompt}'")
+        elif user_input.lower().startswith("!both "):
+            use_mcps_flag = True
+            use_data_store_flag = True
+            prompt = user_input[6:].strip()
+            ASCIIColors.yellow(f"Agentic MCP+RAG turn initiated for: '{prompt}'")
+        
+        # --- Streaming Callback ---
+        def stream_callback(chunk, msg_type, metadata={}, **kwargs):
+            # Render steps and thoughts in real-time
+            if msg_type == 12: # MSG_TYPE.MSG_TYPE_STEP_START
+                 ASCIIColors.cyan(f"\n> Starting: {chunk}")
+            elif msg_type == 13: # MSG_TYPE.MSG_TYPE_STEP_END
+                 ASCIIColors.cyan(f"> Finished: {chunk}")
+            elif msg_type == 2: # MSG_TYPE.MSG_TYPE_INFO (for thoughts)
+                 ASCIIColors.yellow(f"\n  (Thought): {chunk}")
+            else: # Final answer chunks are printed by the main loop
+                pass # The final answer is printed after the full report
+            return True
+
+        # --- Main Chat Logic ---
+        try:
+            #print("\nAI: ", end="", flush=True)
+            
+            response_dict = discussion.chat(
+                user_message=prompt,
+                use_mcps=use_mcps_flag,
+                use_data_store={"coding_store": mock_rag_query_function} if use_data_store_flag else None,
+                streaming_callback=stream_callback
+            )
+            if use_mcps_flag or use_data_store_flag:
+                print_agentic_results(response_dict)
+            print("\nAI: ", end="")
+            ASCIIColors.green(response_dict['ai_message'].content)            
+
+        except Exception as e:
+            trace_exception(e)
+            print(f"\nAn error occurred during generation.")
+
+if __name__ == "__main__":
+    mcp_procs = start_mcp_servers()
+    try:
+        discussion_session = setup_client_and_discussion()
+        run_chat_console(discussion_session)
+    finally:
+        ASCIIColors.red("\n--- Shutting down MCP servers ---")
+        for proc in mcp_procs:
+            proc.terminate()
+            proc.wait()
+        shutil.rmtree(WORKSPACE_DIR, ignore_errors=True)
+        print("Cleanup complete. Goodbye!")

examples/{run_remote_mcp_example copy.py → mcp_examples/run_remote_mcp_example_v2.py}

@@ -7,6 +7,26 @@ from pathlib import Path
 import json
 from lollms_client import LollmsClient
 import subprocess
+from typing import Optional, List, Dict, Any
+
+
+MOCK_KNOWLEDGE_BASE = {
+    "python_basics.md": [
+        {"chunk_id": 1, "text": "Python is a high-level, interpreted programming language known for its readability and versatility. It was created by Guido van Rossum and first released in 1991."},
+        {"chunk_id": 2, "text": "Key features of Python include dynamic typing, automatic memory management (garbage collection), and a large standard library. It supports multiple programming paradigms, such as procedural, object-oriented, and functional programming."},
+        {"chunk_id": 3, "text": "Common applications of Python include web development (e.g., Django, Flask), data science (e.g., Pandas, NumPy, Scikit-learn), machine learning, artificial intelligence, automation, and scripting."},
+    ],
+    "javascript_info.js": [
+        {"chunk_id": 1, "text": "JavaScript is a scripting language primarily used for front-end web development to create interactive effects within web browsers. It is also used in back-end development (Node.js), mobile app development, and game development."},
+        {"chunk_id": 2, "text": "JavaScript is dynamically typed, prototype-based, and multi-paradigm. Along with HTML and CSS, it is one of the core technologies of the World Wide Web."},
+        {"chunk_id": 3, "text": "Popular JavaScript frameworks and libraries include React, Angular, Vue.js for front-end, and Express.js for Node.js back-end applications."},
+    ],
+    "ai_concepts.txt": [
+        {"chunk_id": 1, "text": "Artificial Intelligence (AI) refers to the simulation of human intelligence in machines that are programmed to think like humans and mimic their actions. The term may also be applied to any machine that exhibits traits associated with a human mind such as learning and problem-solving."},
+        {"chunk_id": 2, "text": "Machine Learning (ML) is a subset of AI that provides systems the ability to automatically learn and improve from experience without being explicitly programmed. Deep Learning (DL) is a further subset of ML based on artificial neural networks with representation learning."},
+        {"chunk_id": 3, "text": "Retrieval Augmented Generation (RAG) is an AI framework for improving the quality of LLM-generated responses by grounding the model on external sources of knowledge to supplement the LLM’s internal representation of information."},
+    ]
+}
 # --- Dynamically adjust Python path to find lollms_client ---
 # This assumes the example script is in a directory, and 'lollms_client' is
 # in a sibling directory or a known relative path. Adjust as needed.
@@ -180,10 +200,54 @@ def main():
         return True # Continue streaming
 
     # --- 4. Use generate_with_mcp ---
+
+    def mock_rag_query_function(
+        query_text: str,
+        vectorizer_name: Optional[str] = None, # Ignored in mock
+        top_k: int = 3,
+        min_similarity_percent: float = 0.0 # Ignored in mock, simple keyword match
+    ) -> List[Dict[str, Any]]:
+        """
+        A mock RAG query function.
+        Performs a simple keyword search in the MOCK_KNOWLEDGE_BASE.
+        """
+        ASCIIColors.magenta(f"  [MOCK RAG] Querying with: '{query_text}', top_k={top_k}")
+        results = []
+        query_lower = query_text.lower()
+        
+        all_chunks = []
+        for file_path, chunks_in_file in MOCK_KNOWLEDGE_BASE.items():
+            for chunk_data in chunks_in_file:
+                all_chunks.append({"file_path": file_path, **chunk_data})
+
+        # Simple keyword matching and scoring (very basic)
+        scored_chunks = []
+        for chunk_info in all_chunks:
+            score = 0
+            for keyword in query_lower.split():
+                if keyword in chunk_info["text"].lower() and len(keyword)>2: # Basic relevance
+                    score += 1
+            if "python" in query_lower and "python" in chunk_info["file_path"].lower(): score+=5
+            if "javascript" in query_lower and "javascript" in chunk_info["file_path"].lower(): score+=5
+            if "ai" in query_lower and "ai" in chunk_info["file_path"].lower(): score+=3
+
+
+            if score > 0 : # Only include if some keywords match
+                # Simulate similarity percentage (higher score = higher similarity)
+                similarity = min(100.0, score * 20.0 + 40.0) # Arbitrary scaling
+                if similarity >= min_similarity_percent:
+                    scored_chunks.append({
+                        "file_path": chunk_info["file_path"],
+                        "chunk_text": chunk_info["text"],
+                        "similarity_percent": similarity,
+                        "_score_for_ranking": score # Internal score for sorting
+                    })
     ASCIIColors.magenta("\n2. Calling generate_with_mcp to get current time...")
     time_prompt = "Hey assistant, what time is it right now?"
-    time_response = client.generate_with_mcp(
+    time_response = client.generate_with_mcp_rag(
         prompt=time_prompt,
+        use_mcps=True,
+        use_data_store={"coding_store":mock_rag_query_function},
         streaming_callback=mcp_streaming_callback,
         interactive_tool_execution=False # Set to True to test interactive mode
     )

lollms_client/__init__.py

@@ -8,7 +8,7 @@ from lollms_client.lollms_utilities import PromptReshaper # Keep general utiliti
 from lollms_client.lollms_mcp_binding import LollmsMCPBinding, LollmsMCPBindingManager
 
 
-__version__ = "0.22.0" # Updated version
+__version__ = "0.24.0" # Updated version
 
 # Optionally, you could define __all__ if you want to be explicit about exports
 __all__ = [