gnosisllm-knowledge 0.2.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

gnosisllm_knowledge/cli/app.py

@@ -1,6 +1,11 @@
 """GnosisLLM Knowledge CLI Application.
 
 Main entry point assembling all CLI commands with enterprise-grade UX.
+
+Note:
+    This library is tenant-agnostic. Multi-tenancy is achieved through index
+    isolation - each tenant should use a separate index (e.g., "knowledge-{account_id}").
+    Use --index to target tenant-specific indices.
 """
 
 from __future__ import annotations
@@ -63,13 +68,13 @@ def main_callback(
 @app.command()
 def setup(
     host: Annotated[
-        str,
-        typer.Option("--host", "-h", help="OpenSearch host."),
-    ] = "localhost",
+        Optional[str],
+        typer.Option("--host", "-h", help="OpenSearch host (default: from OPENSEARCH_HOST env)."),
+    ] = None,
     port: Annotated[
-        int,
-        typer.Option("--port", "-p", help="OpenSearch port."),
-    ] = 9200,
+        Optional[int],
+        typer.Option("--port", "-p", help="OpenSearch port (default: from OPENSEARCH_PORT env)."),
+    ] = None,
     username: Annotated[
         Optional[str],
         typer.Option("--username", "-u", help="OpenSearch username."),
@@ -79,13 +84,13 @@ def setup(
         typer.Option("--password", help="OpenSearch password."),
     ] = None,
     use_ssl: Annotated[
-        bool,
-        typer.Option("--use-ssl", help="Enable SSL."),
-    ] = False,
+        Optional[bool],
+        typer.Option("--use-ssl/--no-ssl", help="Enable/disable SSL (default: from OPENSEARCH_USE_SSL env)."),
+    ] = None,
     verify_certs: Annotated[
-        bool,
-        typer.Option("--verify-certs", help="Verify SSL certificates."),
-    ] = False,
+        Optional[bool],
+        typer.Option("--verify-certs/--no-verify-certs", help="Verify SSL certificates."),
+    ] = None,
     force: Annotated[
         bool,
         typer.Option("--force", "-f", help="Clean up existing resources first."),
@@ -147,17 +152,13 @@ def load(
         typer.Option(
             "--type",
             "-t",
-            help="Source type: website, sitemap (auto-detects if not specified).",
+            help="Source type: website, sitemap, discovery (auto-detects if not specified).",
         ),
     ] = None,
     index: Annotated[
         str,
-        typer.Option("--index", "-i", help="Target index name."),
+        typer.Option("--index", "-i", help="Target index name (use tenant-specific name for multi-tenancy)."),
     ] = "knowledge",
-    account_id: Annotated[
-        Optional[str],
-        typer.Option("--account-id", "-a", help="Multi-tenant account ID."),
-    ] = None,
     collection_id: Annotated[
         Optional[str],
         typer.Option("--collection-id", "-c", help="Collection grouping ID."),
@@ -186,16 +187,50 @@ def load(
         bool,
         typer.Option("--verbose", "-V", help="Show per-document progress."),
     ] = False,
+    discovery: Annotated[
+        bool,
+        typer.Option(
+            "--discovery",
+            "-D",
+            help="Use discovery loader to crawl and discover all URLs from the website.",
+        ),
+    ] = False,
+    max_depth: Annotated[
+        int,
+        typer.Option("--max-depth", help="Maximum crawl depth for discovery (default: 3)."),
+    ] = 3,
+    max_pages: Annotated[
+        int,
+        typer.Option("--max-pages", help="Maximum pages to discover (default: 100)."),
+    ] = 100,
+    same_domain: Annotated[
+        bool,
+        typer.Option(
+            "--same-domain/--any-domain",
+            help="Only crawl URLs on the same domain (default: same domain only).",
+        ),
+    ] = True,
 ) -> None:
     """Load and index content from URLs or sitemaps.
 
     Fetches content, chunks it for optimal embedding, and indexes
     into OpenSearch with automatic embedding generation.
 
+    [bold]Multi-tenancy:[/bold]
+    Use --index with tenant-specific index names for isolation
+    (e.g., --index knowledge-{account_id}). Each tenant's data
+    is stored in a separate index for complete isolation.
+
+    [bold]Discovery Mode:[/bold]
+    Use --discovery to crawl and discover all URLs from a website
+    before loading. This is useful for sites without a sitemap.
+
     [bold]Example:[/bold]
         $ gnosisllm-knowledge load https://docs.example.com/intro
         $ gnosisllm-knowledge load https://example.com/sitemap.xml --type sitemap
         $ gnosisllm-knowledge load https://docs.example.com/sitemap.xml --max-urls 500
+        $ gnosisllm-knowledge load https://docs.example.com --discovery --max-depth 5
+        $ gnosisllm-knowledge load https://docs.example.com --index knowledge-tenant-123
     """
     from gnosisllm_knowledge.cli.commands.load import load_command
 
@@ -205,7 +240,6 @@ def load(
             source=source,
             source_type=source_type,
             index_name=index,
-            account_id=account_id,
             collection_id=collection_id,
             source_id=source_id,
             batch_size=batch_size,
@@ -213,6 +247,10 @@ def load(
             force=force,
             dry_run=dry_run,
             verbose=verbose,
+            discovery=discovery,
+            max_depth=max_depth,
+            max_pages=max_pages,
+            same_domain=same_domain,
         )
     )
 
@@ -238,7 +276,7 @@ def search(
     ] = "hybrid",
     index: Annotated[
         str,
-        typer.Option("--index", "-i", help="Index to search."),
+        typer.Option("--index", "-i", help="Index to search (use tenant-specific name for multi-tenancy)."),
     ] = "knowledge",
     limit: Annotated[
         int,
@@ -248,10 +286,6 @@ def search(
         int,
         typer.Option("--offset", "-o", help="Pagination offset."),
     ] = 0,
-    account_id: Annotated[
-        Optional[str],
-        typer.Option("--account-id", "-a", help="Filter by account ID."),
-    ] = None,
     collection_ids: Annotated[
         Optional[str],
         typer.Option("--collection-ids", "-c", help="Filter by collection IDs (comma-separated)."),
@@ -289,10 +323,16 @@ def search(
     - [cyan]hybrid[/cyan]: Combined semantic + keyword (default, best results)
     - [cyan]agentic[/cyan]: AI-powered search with reasoning
 
+    [bold]Multi-tenancy:[/bold]
+    Use --index with tenant-specific index names for isolation
+    (e.g., --index knowledge-{account_id}). Each tenant's data
+    is stored in a separate index for complete isolation.
+
     [bold]Example:[/bold]
         $ gnosisllm-knowledge search "how to configure auth"
         $ gnosisllm-knowledge search "API reference" --mode semantic --limit 10
         $ gnosisllm-knowledge search --interactive
+        $ gnosisllm-knowledge search "query" --index knowledge-tenant-123
     """
     from gnosisllm_knowledge.cli.commands.search import search_command
 
@@ -304,7 +344,6 @@ def search(
             index_name=index,
             limit=limit,
             offset=offset,
-            account_id=account_id,
             collection_ids=collection_ids,
             source_ids=source_ids,
             min_score=min_score,
@@ -367,6 +406,18 @@ def info() -> None:
 
     display.newline()
 
+    display.table(
+        "Agentic Memory Configuration",
+        [
+            ("LLM Model ID", config.memory_llm_model_id or "[dim]Not set[/dim]"),
+            ("Embedding Model ID", config.memory_embedding_model_id or "[dim]Not set[/dim]"),
+            ("LLM Model", config.memory_llm_model),
+            ("Embedding Model", config.memory_embedding_model),
+        ],
+    )
+
+    display.newline()
+
     display.table(
         "Content Fetching",
         [
@@ -439,7 +490,7 @@ def agentic_setup(
 def agentic_chat(
     index: Annotated[
         str,
-        typer.Option("--index", "-i", help="Index to search."),
+        typer.Option("--index", "-i", help="Index to search (use tenant-specific name for multi-tenancy)."),
     ] = "knowledge",
     agent_type: Annotated[
         str,
@@ -449,10 +500,6 @@ def agentic_chat(
             help="Agent type: flow or conversational (default).",
         ),
     ] = "conversational",
-    account_id: Annotated[
-        Optional[str],
-        typer.Option("--account-id", "-a", help="Filter by account ID."),
-    ] = None,
     collection_ids: Annotated[
         Optional[str],
         typer.Option("--collection-ids", "-c", help="Filter by collection IDs (comma-separated)."),
@@ -467,10 +514,15 @@ def agentic_chat(
     Start a conversation with the AI-powered knowledge assistant.
     The agent remembers context for multi-turn dialogue.
 
+    [bold]Multi-tenancy:[/bold]
+    Use --index with tenant-specific index names for isolation
+    (e.g., --index knowledge-{account_id}).
+
     [bold]Example:[/bold]
         $ gnosisllm-knowledge agentic chat
         $ gnosisllm-knowledge agentic chat --type flow
         $ gnosisllm-knowledge agentic chat --verbose
+        $ gnosisllm-knowledge agentic chat --index knowledge-tenant-123
     """
     from gnosisllm_knowledge.cli.commands.agentic import agentic_chat_command
 
@@ -479,7 +531,6 @@ def agentic_chat(
             display=display,
             index_name=index,
             agent_type=agent_type,
-            account_id=account_id,
             collection_ids=collection_ids,
             verbose=verbose,
         )
@@ -500,6 +551,360 @@ def agentic_status() -> None:
     asyncio.run(agentic_status_command(display=display))
 
 
+# ============================================================================
+# MEMORY SUBCOMMAND GROUP
+# ============================================================================
+
+memory_app = typer.Typer(
+    name="memory",
+    help="Agentic Memory management commands.",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+)
+app.add_typer(memory_app, name="memory")
+
+# Container sub-subcommand
+container_app = typer.Typer(
+    name="container",
+    help="Memory container management.",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+)
+memory_app.add_typer(container_app, name="container")
+
+# Session sub-subcommand
+session_app = typer.Typer(
+    name="session",
+    help="Session management.",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+)
+memory_app.add_typer(session_app, name="session")
+
+
+@memory_app.command("setup")
+def memory_setup(
+    openai_key: Annotated[
+        Optional[str],
+        typer.Option("--openai-key", envvar="OPENAI_API_KEY", help="OpenAI API key for connector setup."),
+    ] = None,
+    llm_model: Annotated[
+        str,
+        typer.Option("--llm-model", help="LLM model for fact extraction."),
+    ] = "gpt-4o",
+    embedding_model: Annotated[
+        str,
+        typer.Option("--embedding-model", help="Embedding model name."),
+    ] = "text-embedding-3-small",
+) -> None:
+    """Setup OpenSearch for Agentic Memory.
+
+    Creates the required LLM and embedding connectors and models
+    for Agentic Memory to work.
+
+    [bold]Example:[/bold]
+        $ gnosisllm-knowledge memory setup --openai-key sk-...
+        $ gnosisllm-knowledge memory setup --llm-model gpt-4o --embedding-model text-embedding-3-small
+    """
+    from gnosisllm_knowledge.cli.commands.memory import memory_setup_command
+
+    asyncio.run(
+        memory_setup_command(
+            display=display,
+            openai_key=openai_key,
+            llm_model=llm_model,
+            embedding_model=embedding_model,
+        )
+    )
+
+
+@memory_app.command("status")
+def memory_status() -> None:
+    """Show memory configuration status.
+
+    Displays configured models and verifies their health.
+
+    [bold]Example:[/bold]
+        $ gnosisllm-knowledge memory status
+    """
+    from gnosisllm_knowledge.cli.commands.memory import memory_status_command
+
+    asyncio.run(memory_status_command(display=display))
+
+
+@memory_app.command("store")
+def memory_store(
+    container_id: Annotated[
+        str,
+        typer.Argument(help="Container ID to store messages in."),
+    ],
+    file: Annotated[
+        Optional[str],
+        typer.Option("--file", "-f", help="JSON file with messages."),
+    ] = None,
+    user_id: Annotated[
+        Optional[str],
+        typer.Option("--user-id", help="User ID for namespace."),
+    ] = None,
+    session_id: Annotated[
+        Optional[str],
+        typer.Option("--session-id", help="Session ID for namespace."),
+    ] = None,
+    infer: Annotated[
+        bool,
+        typer.Option("--infer/--no-infer", help="Enable/disable fact extraction."),
+    ] = True,
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", "-j", help="Output as JSON."),
+    ] = False,
+) -> None:
+    """Store conversation in memory.
+
+    Stores messages in working memory and optionally extracts facts
+    to long-term memory using LLM inference.
+
+    [bold]Example:[/bold]
+        $ gnosisllm-knowledge memory store <container-id> -f messages.json --user-id alice
+        $ gnosisllm-knowledge memory store <container-id> -f messages.json --no-infer
+    """
+    from gnosisllm_knowledge.cli.commands.memory import memory_store_command
+
+    asyncio.run(
+        memory_store_command(
+            display=display,
+            container_id=container_id,
+            file=file,
+            user_id=user_id,
+            session_id=session_id,
+            infer=infer,
+            json_output=json_output,
+        )
+    )
+
+
+@memory_app.command("recall")
+def memory_recall(
+    container_id: Annotated[
+        str,
+        typer.Argument(help="Container ID to search."),
+    ],
+    query: Annotated[
+        str,
+        typer.Argument(help="Search query text."),
+    ],
+    user_id: Annotated[
+        Optional[str],
+        typer.Option("--user-id", help="Filter by user ID."),
+    ] = None,
+    session_id: Annotated[
+        Optional[str],
+        typer.Option("--session-id", help="Filter by session ID."),
+    ] = None,
+    limit: Annotated[
+        int,
+        typer.Option("--limit", "-n", help="Maximum results."),
+    ] = 10,
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", "-j", help="Output as JSON."),
+    ] = False,
+) -> None:
+    """Search long-term memory.
+
+    Performs semantic search over extracted facts and memories.
+
+    [bold]Example:[/bold]
+        $ gnosisllm-knowledge memory recall <container-id> "user preferences" --user-id alice
+        $ gnosisllm-knowledge memory recall <container-id> "food preferences" --limit 5 --json
+    """
+    from gnosisllm_knowledge.cli.commands.memory import memory_recall_command
+
+    asyncio.run(
+        memory_recall_command(
+            display=display,
+            container_id=container_id,
+            query=query,
+            user_id=user_id,
+            session_id=session_id,
+            limit=limit,
+            json_output=json_output,
+        )
+    )
+
+
+@memory_app.command("stats")
+def memory_stats(
+    container_id: Annotated[
+        str,
+        typer.Argument(help="Container ID."),
+    ],
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", "-j", help="Output as JSON."),
+    ] = False,
+) -> None:
+    """Show container statistics.
+
+    Displays memory counts, session count, and strategy breakdown.
+
+    [bold]Example:[/bold]
+        $ gnosisllm-knowledge memory stats <container-id>
+        $ gnosisllm-knowledge memory stats <container-id> --json
+    """
+    from gnosisllm_knowledge.cli.commands.memory import memory_stats_command
+
+    asyncio.run(
+        memory_stats_command(
+            display=display,
+            container_id=container_id,
+            json_output=json_output,
+        )
+    )
+
+
+# === Container Commands ===
+
+
+@container_app.command("create")
+def container_create(
+    name: Annotated[
+        str,
+        typer.Argument(help="Container name."),
+    ],
+    description: Annotated[
+        Optional[str],
+        typer.Option("--description", "-d", help="Container description."),
+    ] = None,
+    config_file: Annotated[
+        Optional[str],
+        typer.Option("--config", "-c", help="JSON file with strategy configuration."),
+    ] = None,
+) -> None:
+    """Create a new memory container.
+
+    Containers hold memories with configurable extraction strategies.
+    Each strategy is scoped to namespace fields for partitioning.
+
+    [bold]Example config.json:[/bold]
+        {
+          "strategies": [
+            {"type": "SEMANTIC", "namespace": ["user_id"]},
+            {"type": "USER_PREFERENCE", "namespace": ["user_id"]},
+            {"type": "SUMMARY", "namespace": ["session_id"]}
+          ]
+        }
+
+    [bold]Example:[/bold]
+        $ gnosisllm-knowledge memory container create my-memory
+        $ gnosisllm-knowledge memory container create agent-memory -c config.json
+    """
+    from gnosisllm_knowledge.cli.commands.memory import container_create_command
+
+    asyncio.run(
+        container_create_command(
+            display=display,
+            name=name,
+            description=description,
+            config_file=config_file,
+        )
+    )
+
+
+@container_app.command("list")
+def container_list(
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", "-j", help="Output as JSON."),
+    ] = False,
+) -> None:
+    """List all memory containers.
+
+    [bold]Example:[/bold]
+        $ gnosisllm-knowledge memory container list
+        $ gnosisllm-knowledge memory container list --json
+    """
+    from gnosisllm_knowledge.cli.commands.memory import container_list_command
+
+    asyncio.run(
+        container_list_command(
+            display=display,
+            json_output=json_output,
+        )
+    )
+
+
+@container_app.command("delete")
+def container_delete(
+    container_id: Annotated[
+        str,
+        typer.Argument(help="Container ID to delete."),
+    ],
+    force: Annotated[
+        bool,
+        typer.Option("--force", "-f", help="Skip confirmation prompt."),
+    ] = False,
+) -> None:
+    """Delete a memory container.
+
+    This permanently deletes the container and all its memories.
+
+    [bold]Example:[/bold]
+        $ gnosisllm-knowledge memory container delete <container-id>
+        $ gnosisllm-knowledge memory container delete <container-id> --force
+    """
+    from gnosisllm_knowledge.cli.commands.memory import container_delete_command
+
+    asyncio.run(
+        container_delete_command(
+            display=display,
+            container_id=container_id,
+            force=force,
+        )
+    )
+
+
+# === Session Commands ===
+
+
+@session_app.command("list")
+def session_list(
+    container_id: Annotated[
+        str,
+        typer.Argument(help="Container ID."),
+    ],
+    user_id: Annotated[
+        Optional[str],
+        typer.Option("--user-id", help="Filter by user ID."),
+    ] = None,
+    limit: Annotated[
+        int,
+        typer.Option("--limit", "-n", help="Maximum sessions."),
+    ] = 20,
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", "-j", help="Output as JSON."),
+    ] = False,
+) -> None:
+    """List sessions in a container.
+
+    [bold]Example:[/bold]
+        $ gnosisllm-knowledge memory session list <container-id>
+        $ gnosisllm-knowledge memory session list <container-id> --user-id alice
+    """
+    from gnosisllm_knowledge.cli.commands.memory import session_list_command
+
+    asyncio.run(
+        session_list_command(
+            display=display,
+            container_id=container_id,
+            user_id=user_id,
+            limit=limit,
+            json_output=json_output,
+        )
+    )
+
+
 def main() -> None:
     """CLI entry point."""
     app()

gnosisllm_knowledge/cli/commands/agentic.py

@@ -4,6 +4,10 @@ Commands:
 - setup: Configure agents in OpenSearch
 - chat: Interactive agentic chat session
 - status: Show agent configuration status
+
+Note:
+    This library is tenant-agnostic. Multi-tenancy is achieved through index
+    isolation - each tenant should use a separate index (e.g., "knowledge-{account_id}").
 """
 
 from __future__ import annotations
@@ -105,6 +109,17 @@ async def agentic_setup_command(
         if agent_type in ("conversational", "all"):
             agent_types_to_setup.append("conversational")
 
+        # If force, cleanup existing agents first
+        if force:
+            display.info("Force mode: cleaning up existing agents...")
+            try:
+                cleanup_result = await adapter.cleanup_agents()
+                for step in cleanup_result.steps_completed:
+                    display.success(step)
+            except Exception as e:
+                display.warning(f"Cleanup warning (continuing): {e}")
+            display.newline()
+
         # Build step list
         steps = []
         if "flow" in agent_types_to_setup:
@@ -191,17 +206,19 @@ async def agentic_chat_command(
     display: RichDisplayService,
     index_name: str = "knowledge",
     agent_type: str = "conversational",
-    account_id: str | None = None,
     collection_ids: str | None = None,
     verbose: bool = False,
 ) -> None:
     """Interactive agentic chat session.
 
+    Note:
+        Multi-tenancy is achieved through index isolation. Use tenant-specific
+        index names instead (e.g., --index knowledge-tenant-123).
+
     Args:
         display: Display service for output.
-        index_name: Index to search.
+        index_name: Index to search (use tenant-specific name for isolation).
         agent_type: Agent type ('flow' or 'conversational').
-        account_id: Filter by account ID.
         collection_ids: Filter by collection IDs (comma-separated).
         verbose: Show reasoning steps.
     """
@@ -231,7 +248,6 @@ async def agentic_chat_command(
         if agent_type == "conversational":
             return await searcher.create_conversation(
                 name="CLI Chat Session",
-                account_id=account_id,
             )
         return None
 
@@ -280,7 +296,6 @@ async def agentic_chat_command(
                     agent_type=AgentType.CONVERSATIONAL if agent_type == "conversational" else AgentType.FLOW,
                     conversation_id=conversation_id,
                     collection_ids=collection_list,
-                    account_id=account_id,
                     include_reasoning=verbose,
                 )
 
@@ -384,7 +399,6 @@ async def agentic_search_command(
     query: str,
     index_name: str = "knowledge",
     agent_type: str = "flow",
-    account_id: str | None = None,
     collection_ids: str | None = None,
     source_ids: str | None = None,
     limit: int = 5,
@@ -393,12 +407,15 @@ async def agentic_search_command(
 ) -> dict[str, Any] | None:
     """Execute agentic search.
 
+    Note:
+        Multi-tenancy is achieved through index isolation. Use tenant-specific
+        index names instead (e.g., --index knowledge-tenant-123).
+
     Args:
         display: Display service for output.
         query: Search query text.
-        index_name: Index to search.
+        index_name: Index to search (use tenant-specific name for isolation).
         agent_type: Agent type ('flow' or 'conversational').
-        account_id: Filter by account ID.
         collection_ids: Filter by collection IDs (comma-separated).
         source_ids: Filter by source IDs (comma-separated).
         limit: Maximum source documents to retrieve.
@@ -436,12 +453,12 @@ async def agentic_search_command(
             )
 
         # Build query
+        # Note: account_id is deprecated and ignored - use index isolation instead
         agentic_query = AgenticSearchQuery(
             text=query,
             agent_type=AgentType.CONVERSATIONAL if agent_type == "conversational" else AgentType.FLOW,
             collection_ids=collection_list,
             source_ids=source_list,
-            account_id=account_id,
             limit=limit,
             include_reasoning=verbose,
         )