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

gnosisllm_knowledge/cli/app.py

@@ -63,13 +63,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 +79,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."),
@@ -367,6 +367,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",
         [
@@ -500,6 +512,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

@@ -105,6 +105,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: