API Updates: fleshing out RAG APIs, introduce "llama stack" CLI command (#51)

* add tools to chat completion request

* use templates for generating system prompts

* Moved ToolPromptFormat and jinja templates to llama_models.llama3.api

* <WIP> memory changes

- inlined AgenticSystemInstanceConfig so API feels more ergonomic
- renamed it to AgentConfig, AgentInstance -> Agent
- added a MemoryConfig and `memory` parameter
- added `attachments` to input and `output_attachments` to the response

- some naming changes

* InterleavedTextAttachment -> InterleavedTextMedia, introduce memory tool

* flesh out memory banks API

* agentic loop has a RAG implementation

* faiss provider implementation

* memory client works

* re-work tool definitions, fix FastAPI issues, fix tool regressions

* fix agentic_system utils

* basic RAG seems to work

* small bug fixes for inline attachments

* Refactor custom tool execution utilities

* Bug fix, show memory retrieval steps in EventLogger

* No need for api_key for Remote providers

* add special unicode character ↵ to showcase newlines in model prompt templates

* remove api.endpoints imports

* combine datatypes.py and endpoints.py into api.py

* Attachment / add TTL api

* split batch_inference from inference

* minor import fixes

* use a single impl for ChatFormat.decode_assistant_mesage

* use interleaved_text_media_as_str() utilityt

* Fix api.datatypes imports

* Add blobfile for tiktoken

* Add ToolPromptFormat to ChatFormat.encode_message so that tools are encoded properly

* templates take optional --format={json,function_tag}

* Rag Updates

* Add `api build` subcommand -- WIP

* fix

* build + run image seems to work

* <WIP> adapters

* bunch more work to make adapters work

* api build works for conda now

* ollama remote adapter works

* Several smaller fixes to make adapters work

Also, reorganized the pattern of __init__ inside providers so
configuration can stay lightweight

* llama distribution -> llama stack + containers (WIP)

* All the new CLI for api + stack work

* Make Fireworks and Together into the Adapter format

* Some quick fixes to the CLI behavior to make it consistent

* Updated README phew

* Update cli_reference.md

* llama_toolchain/distribution -> llama_toolchain/core

* Add termcolor

* update paths

* Add a log just for consistency

* chmod +x scripts

* Fix api dependencies not getting added to configuration

* missing import lol

* Delete utils.py; move to agentic system

* Support downloading of URLs for attachments for code interpreter

* Simplify and generalize `llama api build` yay

* Update `llama stack configure` to be very simple also

* Fix stack start

* Allow building an "adhoc" distribution

* Remote `llama api []` subcommands

* Fixes to llama stack commands and update docs

* Update documentation again and add error messages to llama stack start

* llama stack start -> llama stack run

* Change name of build for less confusion

* Add pyopenapi fork to the repository, update RFC assets

* Remove conflicting annotation

* Added a "--raw" option for model template printing

---------

Co-authored-by: Hardik Shah <hjshah@fb.com>
Co-authored-by: Ashwin Bharambe <ashwin@meta.com>
Co-authored-by: Dalton Flanagan <6599399+dltn@users.noreply.github.com>

llama_toolchain/core/package.py

@@ -0,0 +1,149 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the terms described in the LICENSE file in
+# the root directory of this source tree.
+
+import json
+import os
+from datetime import datetime
+from enum import Enum
+from typing import List, Optional
+
+import pkg_resources
+import yaml
+from pydantic import BaseModel
+
+from termcolor import cprint
+
+from llama_toolchain.common.config_dirs import BUILDS_BASE_DIR
+from llama_toolchain.common.exec import run_with_pty
+from llama_toolchain.common.serialize import EnumEncoder
+
+from llama_toolchain.core.datatypes import *  # noqa: F403
+from llama_toolchain.core.distribution import api_providers, SERVER_DEPENDENCIES
+
+
+class BuildType(Enum):
+    container = "container"
+    conda_env = "conda_env"
+
+    def descriptor(self) -> str:
+        return "docker" if self == self.container else "conda"
+
+
+class Dependencies(BaseModel):
+    pip_packages: List[str]
+    docker_image: Optional[str] = None
+
+
+class ApiInput(BaseModel):
+    api: Api
+    provider: str
+
+
+def build_package(
+    api_inputs: List[ApiInput],
+    build_type: BuildType,
+    name: str,
+    distribution_id: Optional[str] = None,
+    docker_image: Optional[str] = None,
+):
+    if not distribution_id:
+        distribution_id = "adhoc"
+
+    build_dir = BUILDS_BASE_DIR / distribution_id / build_type.descriptor()
+    os.makedirs(build_dir, exist_ok=True)
+
+    package_name = name.replace("::", "-")
+    package_file = build_dir / f"{package_name}.yaml"
+
+    all_providers = api_providers()
+
+    package_deps = Dependencies(
+        docker_image=docker_image or "python:3.10-slim",
+        pip_packages=SERVER_DEPENDENCIES,
+    )
+
+    stub_config = {}
+    for api_input in api_inputs:
+        api = api_input.api
+        providers_for_api = all_providers[api]
+        if api_input.provider not in providers_for_api:
+            raise ValueError(
+                f"Provider `{api_input.provider}` is not available for API `{api}`"
+            )
+
+        provider = providers_for_api[api_input.provider]
+        package_deps.pip_packages.extend(provider.pip_packages)
+        if provider.docker_image:
+            raise ValueError("A stack's dependencies cannot have a docker image")
+
+        stub_config[api.value] = {"provider_id": api_input.provider}
+
+    if package_file.exists():
+        cprint(
+            f"Build `{package_name}` exists; will reconfigure",
+            color="yellow",
+        )
+        c = PackageConfig(**yaml.safe_load(package_file.read_text()))
+        for api_str, new_config in stub_config.items():
+            if api_str not in c.providers:
+                c.providers[api_str] = new_config
+            else:
+                existing_config = c.providers[api_str]
+                if existing_config["provider_id"] != new_config["provider_id"]:
+                    cprint(
+                        f"Provider `{api_str}` has changed from `{existing_config}` to `{new_config}`",
+                        color="yellow",
+                    )
+                    c.providers[api_str] = new_config
+    else:
+        c = PackageConfig(
+            built_at=datetime.now(),
+            package_name=package_name,
+            providers=stub_config,
+        )
+
+    c.distribution_id = distribution_id
+    c.docker_image = package_name if build_type == BuildType.container else None
+    c.conda_env = package_name if build_type == BuildType.conda_env else None
+
+    with open(package_file, "w") as f:
+        to_write = json.loads(json.dumps(c.dict(), cls=EnumEncoder))
+        f.write(yaml.dump(to_write, sort_keys=False))
+
+    if build_type == BuildType.container:
+        script = pkg_resources.resource_filename(
+            "llama_toolchain", "core/build_container.sh"
+        )
+        args = [
+            script,
+            distribution_id,
+            package_name,
+            package_deps.docker_image,
+            " ".join(package_deps.pip_packages),
+        ]
+    else:
+        script = pkg_resources.resource_filename(
+            "llama_toolchain", "core/build_conda_env.sh"
+        )
+        args = [
+            script,
+            distribution_id,
+            package_name,
+            " ".join(package_deps.pip_packages),
+        ]
+
+    return_code = run_with_pty(args)
+    if return_code != 0:
+        cprint(
+            f"Failed to build target {package_name} with return code {return_code}",
+            color="red",
+        )
+        return
+
+    cprint(
+        f"Target `{package_name}` built with configuration at {str(package_file)}",
+        color="green",
+    )