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>

rfcs/openapi_generator/pyopenapi/utility.py

@@ -0,0 +1,116 @@
+# 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 typing
+from pathlib import Path
+from typing import TextIO
+
+from strong_typing.schema import object_to_json, StrictJsonType
+
+from .generator import Generator
+from .options import Options
+from .specification import Document
+
+
+THIS_DIR = Path(__file__).parent
+
+
+class Specification:
+    document: Document
+
+    def __init__(self, endpoint: type, options: Options):
+        generator = Generator(endpoint, options)
+        self.document = generator.generate()
+
+    def get_json(self) -> StrictJsonType:
+        """
+        Returns the OpenAPI specification as a Python data type (e.g. `dict` for an object, `list` for an array).
+
+        The result can be serialized to a JSON string with `json.dump` or `json.dumps`.
+        """
+
+        json_doc = typing.cast(StrictJsonType, object_to_json(self.document))
+
+        if isinstance(json_doc, dict):
+            # rename vendor-specific properties
+            tag_groups = json_doc.pop("tagGroups", None)
+            if tag_groups:
+                json_doc["x-tagGroups"] = tag_groups
+            tags = json_doc.get("tags")
+            if tags and isinstance(tags, list):
+                for tag in tags:
+                    if not isinstance(tag, dict):
+                        continue
+
+                    display_name = tag.pop("displayName", None)
+                    if display_name:
+                        tag["x-displayName"] = display_name
+
+        return json_doc
+
+    def get_json_string(self, pretty_print: bool = False) -> str:
+        """
+        Returns the OpenAPI specification as a JSON string.
+
+        :param pretty_print: Whether to use line indents to beautify the output.
+        """
+
+        json_doc = self.get_json()
+        if pretty_print:
+            return json.dumps(
+                json_doc, check_circular=False, ensure_ascii=False, indent=4
+            )
+        else:
+            return json.dumps(
+                json_doc,
+                check_circular=False,
+                ensure_ascii=False,
+                separators=(",", ":"),
+            )
+
+    def write_json(self, f: TextIO, pretty_print: bool = False) -> None:
+        """
+        Writes the OpenAPI specification to a file as a JSON string.
+
+        :param pretty_print: Whether to use line indents to beautify the output.
+        """
+
+        json_doc = self.get_json()
+        if pretty_print:
+            json.dump(
+                json_doc,
+                f,
+                check_circular=False,
+                ensure_ascii=False,
+                indent=4,
+            )
+        else:
+            json.dump(
+                json_doc,
+                f,
+                check_circular=False,
+                ensure_ascii=False,
+                separators=(",", ":"),
+            )
+
+    def write_html(self, f: TextIO, pretty_print: bool = False) -> None:
+        """
+        Creates a stand-alone HTML page for the OpenAPI specification with ReDoc.
+
+        :param pretty_print: Whether to use line indents to beautify the JSON string in the HTML file.
+        """
+
+        path = THIS_DIR / "template.html"
+        with path.open(encoding="utf-8", errors="strict") as html_template_file:
+            html_template = html_template_file.read()
+
+        html = html_template.replace(
+            "{ /* OPENAPI_SPECIFICATION */ }",
+            self.get_json_string(pretty_print=pretty_print),
+        )
+
+        f.write(html)