letta-nightly 0.4.1.dev20241004104123__py3-none-any.whl → 0.4.1.dev20241006104046__py3-none-any.whl

letta/cli/cli.py

@@ -1,26 +1,19 @@
-import json
 import logging
-import os
 import sys
 from enum import Enum
 from typing import Annotated, Optional
 
 import questionary
-import requests
 import typer
 
 import letta.utils as utils
 from letta import create_client
 from letta.agent import Agent, save_agent
-from letta.cli.cli_config import configure
 from letta.config import LettaConfig
 from letta.constants import CLI_WARNING_PREFIX, LETTA_DIR
-from letta.credentials import LettaCredentials
 from letta.log import get_logger
 from letta.metadata import MetadataStore
-from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import OptionState
-from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import ChatMemory, Memory
 from letta.server.server import logger as server_logger
 
@@ -33,256 +26,6 @@ from letta.utils import open_folder_in_explorer, printd
 logger = get_logger(__name__)
 
 
-class QuickstartChoice(Enum):
-    openai = "openai"
-    # azure = "azure"
-    letta_hosted = "letta"
-    anthropic = "anthropic"
-
-
-def str_to_quickstart_choice(choice_str: str) -> QuickstartChoice:
-    try:
-        return QuickstartChoice[choice_str]
-    except KeyError:
-        valid_options = [choice.name for choice in QuickstartChoice]
-        raise ValueError(f"{choice_str} is not a valid QuickstartChoice. Valid options are: {valid_options}")
-
-
-def set_config_with_dict(new_config: dict) -> (LettaConfig, bool):
-    """_summary_
-
-    Args:
-        new_config (dict): Dict of new config values
-
-    Returns:
-        new_config LettaConfig, modified (bool): Returns the new config and a boolean indicating if the config was modified
-    """
-    from letta.utils import printd
-
-    old_config = LettaConfig.load()
-    modified = False
-    for k, v in vars(old_config).items():
-        if k in new_config:
-            if v != new_config[k]:
-                printd(f"Replacing config {k}: {v} -> {new_config[k]}")
-                modified = True
-                # old_config[k] = new_config[k]
-                setattr(old_config, k, new_config[k])  # Set the new value using dot notation
-            else:
-                printd(f"Skipping new config {k}: {v} == {new_config[k]}")
-
-    # update embedding config
-    if old_config.default_embedding_config:
-        for k, v in vars(old_config.default_embedding_config).items():
-            if k in new_config:
-                if v != new_config[k]:
-                    printd(f"Replacing config {k}: {v} -> {new_config[k]}")
-                    modified = True
-                    # old_config[k] = new_config[k]
-                    setattr(old_config.default_embedding_config, k, new_config[k])
-                else:
-                    printd(f"Skipping new config {k}: {v} == {new_config[k]}")
-    else:
-        modified = True
-        fields = ["embedding_model", "embedding_dim", "embedding_chunk_size", "embedding_endpoint", "embedding_endpoint_type"]
-        args = {}
-        for field in fields:
-            if field in new_config:
-                args[field] = new_config[field]
-                printd(f"Setting new config {field}: {new_config[field]}")
-        old_config.default_embedding_config = EmbeddingConfig(**args)
-
-    # update llm config
-    if old_config.default_llm_config:
-        for k, v in vars(old_config.default_llm_config).items():
-            if k in new_config:
-                if v != new_config[k]:
-                    printd(f"Replacing config {k}: {v} -> {new_config[k]}")
-                    modified = True
-                    # old_config[k] = new_config[k]
-                    setattr(old_config.default_llm_config, k, new_config[k])
-                else:
-                    printd(f"Skipping new config {k}: {v} == {new_config[k]}")
-    else:
-        modified = True
-        fields = ["model", "model_endpoint", "model_endpoint_type", "model_wrapper", "context_window"]
-        args = {}
-        for field in fields:
-            if field in new_config:
-                args[field] = new_config[field]
-                printd(f"Setting new config {field}: {new_config[field]}")
-        old_config.default_llm_config = LLMConfig(**args)
-    return (old_config, modified)
-
-
-def quickstart(
-    backend: Annotated[QuickstartChoice, typer.Option(help="Quickstart setup backend")] = "letta",
-    latest: Annotated[bool, typer.Option(help="Use --latest to pull the latest config from online")] = False,
-    debug: Annotated[bool, typer.Option(help="Use --debug to enable debugging output")] = False,
-    terminal: bool = True,
-):
-    """Set the base config file with a single command
-
-    This function and `configure` should be the ONLY places where LettaConfig.save() is called.
-    """
-
-    # setup logger
-    utils.DEBUG = debug
-    logging.getLogger().setLevel(logging.CRITICAL)
-    if debug:
-        logging.getLogger().setLevel(logging.DEBUG)
-
-    # make sure everything is set up properly
-    LettaConfig.create_config_dir()
-    credentials = LettaCredentials.load()
-
-    config_was_modified = False
-    if backend == QuickstartChoice.letta_hosted:
-        # if latest, try to pull the config from the repo
-        # fallback to using local
-        if latest:
-            # Download the latest letta hosted config
-            url = "https://raw.githubusercontent.com/cpacker/Letta/main/configs/letta_hosted.json"
-            response = requests.get(url)
-
-            # Check if the request was successful
-            if response.status_code == 200:
-                # Parse the response content as JSON
-                config = response.json()
-                # Output a success message and the first few items in the dictionary as a sample
-                printd("JSON config file downloaded successfully.")
-                new_config, config_was_modified = set_config_with_dict(config)
-            else:
-                typer.secho(f"Failed to download config from {url}. Status code: {response.status_code}", fg=typer.colors.RED)
-
-                # Load the file from the relative path
-                script_dir = os.path.dirname(__file__)  # Get the directory where the script is located
-                backup_config_path = os.path.join(script_dir, "..", "configs", "letta_hosted.json")
-                try:
-                    with open(backup_config_path, "r", encoding="utf-8") as file:
-                        backup_config = json.load(file)
-                    printd("Loaded backup config file successfully.")
-                    new_config, config_was_modified = set_config_with_dict(backup_config)
-                except FileNotFoundError:
-                    typer.secho(f"Backup config file not found at {backup_config_path}", fg=typer.colors.RED)
-                    return
-        else:
-            # Load the file from the relative path
-            script_dir = os.path.dirname(__file__)  # Get the directory where the script is located
-            backup_config_path = os.path.join(script_dir, "..", "configs", "letta_hosted.json")
-            try:
-                with open(backup_config_path, "r", encoding="utf-8") as file:
-                    backup_config = json.load(file)
-                printd("Loaded config file successfully.")
-                new_config, config_was_modified = set_config_with_dict(backup_config)
-            except FileNotFoundError:
-                typer.secho(f"Config file not found at {backup_config_path}", fg=typer.colors.RED)
-                return
-
-    elif backend == QuickstartChoice.openai:
-        # Make sure we have an API key
-        api_key = os.getenv("OPENAI_API_KEY")
-        while api_key is None or len(api_key) == 0:
-            # Ask for API key as input
-            api_key = questionary.password("Enter your OpenAI API key (starts with 'sk-', see https://platform.openai.com/api-keys):").ask()
-        credentials.openai_key = api_key
-        credentials.save()
-
-        # if latest, try to pull the config from the repo
-        # fallback to using local
-        if latest:
-            url = "https://raw.githubusercontent.com/cpacker/Letta/main/configs/openai.json"
-            response = requests.get(url)
-
-            # Check if the request was successful
-            if response.status_code == 200:
-                # Parse the response content as JSON
-                config = response.json()
-                # Output a success message and the first few items in the dictionary as a sample
-                new_config, config_was_modified = set_config_with_dict(config)
-            else:
-                typer.secho(f"Failed to download config from {url}. Status code: {response.status_code}", fg=typer.colors.RED)
-
-                # Load the file from the relative path
-                script_dir = os.path.dirname(__file__)  # Get the directory where the script is located
-                backup_config_path = os.path.join(script_dir, "..", "configs", "openai.json")
-                try:
-                    with open(backup_config_path, "r", encoding="utf-8") as file:
-                        backup_config = json.load(file)
-                    printd("Loaded backup config file successfully.")
-                    new_config, config_was_modified = set_config_with_dict(backup_config)
-                except FileNotFoundError:
-                    typer.secho(f"Backup config file not found at {backup_config_path}", fg=typer.colors.RED)
-                    return
-        else:
-            # Load the file from the relative path
-            script_dir = os.path.dirname(__file__)  # Get the directory where the script is located
-            backup_config_path = os.path.join(script_dir, "..", "configs", "openai.json")
-            try:
-                with open(backup_config_path, "r", encoding="utf-8") as file:
-                    backup_config = json.load(file)
-                printd("Loaded config file successfully.")
-                new_config, config_was_modified = set_config_with_dict(backup_config)
-            except FileNotFoundError:
-                typer.secho(f"Config file not found at {backup_config_path}", fg=typer.colors.RED)
-                return
-
-    elif backend == QuickstartChoice.anthropic:
-        # Make sure we have an API key
-        api_key = os.getenv("ANTHROPIC_API_KEY")
-        while api_key is None or len(api_key) == 0:
-            # Ask for API key as input
-            api_key = questionary.password("Enter your Anthropic API key:").ask()
-        credentials.anthropic_key = api_key
-        credentials.save()
-
-        script_dir = os.path.dirname(__file__)  # Get the directory where the script is located
-        backup_config_path = os.path.join(script_dir, "..", "configs", "anthropic.json")
-        try:
-            with open(backup_config_path, "r", encoding="utf-8") as file:
-                backup_config = json.load(file)
-            printd("Loaded config file successfully.")
-            new_config, config_was_modified = set_config_with_dict(backup_config)
-        except FileNotFoundError:
-            typer.secho(f"Config file not found at {backup_config_path}", fg=typer.colors.RED)
-            return
-
-    else:
-        raise NotImplementedError(backend)
-
-    if config_was_modified:
-        printd(f"Saving new config file.")
-        new_config.save()
-        typer.secho(f"📖 Letta configuration file updated!", fg=typer.colors.GREEN)
-        typer.secho(
-            "\n".join(
-                [
-                    f"🧠 model\t-> {new_config.default_llm_config.model}",
-                    f"🖥️  endpoint\t-> {new_config.default_llm_config.model_endpoint}",
-                ]
-            ),
-            fg=typer.colors.GREEN,
-        )
-    else:
-        typer.secho(f"📖 Letta configuration file unchanged.", fg=typer.colors.WHITE)
-        typer.secho(
-            "\n".join(
-                [
-                    f"🧠 model\t-> {new_config.default_llm_config.model}",
-                    f"🖥️  endpoint\t-> {new_config.default_llm_config.model_endpoint}",
-                ]
-            ),
-            fg=typer.colors.WHITE,
-        )
-
-    # 'terminal' = quickstart was run alone, in which case we should guide the user on the next command
-    if terminal:
-        if config_was_modified:
-            typer.secho('⚡ Run "letta run" to create an agent with the new config.', fg=typer.colors.YELLOW)
-        else:
-            typer.secho('⚡ Run "letta run" to create an agent.', fg=typer.colors.YELLOW)
-
-
 def open_folder():
     """Open a folder viewer of the Letta home directory"""
     try:
@@ -302,6 +45,7 @@ def server(
     port: Annotated[Optional[int], typer.Option(help="Port to run the server on")] = None,
     host: Annotated[Optional[str], typer.Option(help="Host to run the server on (default to localhost)")] = None,
     debug: Annotated[bool, typer.Option(help="Turn debugging output on")] = False,
+    ade: Annotated[bool, typer.Option(help="Allows remote access")] = False,
 ):
     """Launch a Letta server process"""
 
@@ -383,83 +127,8 @@ def run(
         logger.setLevel(logging.CRITICAL)
         server_logger.setLevel(logging.CRITICAL)
 
-    # from letta.migrate import (
-    #    VERSION_CUTOFF,
-    #    config_is_compatible,
-    #    wipe_config_and_reconfigure,
-    # )
-
-    # if not config_is_compatible(allow_empty=True):
-    #    typer.secho(f"\nYour current config file is incompatible with Letta versions later than {VERSION_CUTOFF}\n", fg=typer.colors.RED)
-    #    choices = [
-    #        "Run the full config setup (recommended)",
-    #        "Create a new config using defaults",
-    #        "Cancel",
-    #    ]
-    #    selection = questionary.select(
-    #        f"To use Letta, you must either downgrade your Letta version (<= {VERSION_CUTOFF}), or regenerate your config. Would you like to proceed?",
-    #        choices=choices,
-    #        default=choices[0],
-    #    ).ask()
-    #    if selection == choices[0]:
-    #        try:
-    #            wipe_config_and_reconfigure()
-    #        except Exception as e:
-    #            typer.secho(f"Fresh config generation failed - error:\n{e}", fg=typer.colors.RED)
-    #            raise
-    #    elif selection == choices[1]:
-    #        try:
-    #            # Don't create a config, so that the next block of code asking about quickstart is run
-    #            wipe_config_and_reconfigure(run_configure=False, create_config=False)
-    #        except Exception as e:
-    #            typer.secho(f"Fresh config generation failed - error:\n{e}", fg=typer.colors.RED)
-    #            raise
-    #    else:
-    #        typer.secho("Letta config regeneration cancelled", fg=typer.colors.RED)
-    #        raise KeyboardInterrupt()
-
-    #    typer.secho("Note: if you would like to migrate old agents to the new release, please run `letta migrate`!", fg=typer.colors.GREEN)
-
-    if not LettaConfig.exists():
-        # if no config, ask about quickstart
-        # do you want to do:
-        # - openai (run quickstart)
-        # - letta hosted (run quickstart)
-        # - other (run configure)
-        if yes:
-            # if user is passing '-y' to bypass all inputs, use letta hosted
-            # since it can't fail out if you don't have an API key
-            quickstart(backend=QuickstartChoice.letta_hosted)
-            config = LettaConfig()
-
-        else:
-            config_choices = {
-                "letta": "Use the free Letta endpoints",
-                "openai": "Use OpenAI (requires an OpenAI API key)",
-                "other": "Other (OpenAI Azure, custom LLM endpoint, etc)",
-            }
-            print()
-            config_selection = questionary.select(
-                "How would you like to set up Letta?",
-                choices=list(config_choices.values()),
-                default=config_choices["letta"],
-            ).ask()
-
-            if config_selection == config_choices["letta"]:
-                print()
-                quickstart(backend=QuickstartChoice.letta_hosted, debug=debug, terminal=False, latest=False)
-            elif config_selection == config_choices["openai"]:
-                print()
-                quickstart(backend=QuickstartChoice.openai, debug=debug, terminal=False, latest=False)
-            elif config_selection == config_choices["other"]:
-                configure()
-            else:
-                raise ValueError(config_selection)
-
-            config = LettaConfig.load()
-
-    else:  # load config
-        config = LettaConfig.load()
+    # load config file
+    config = LettaConfig.load()
 
     # read user id from config
     ms = MetadataStore(config)
@@ -556,40 +225,36 @@ def run(
         typer.secho("\n🧬 Creating new agent...", fg=typer.colors.WHITE)
 
         agent_name = agent if agent else utils.create_random_username()
-        llm_config = config.default_llm_config
-        embedding_config = config.default_embedding_config  # TODO allow overriding embedding params via CLI run
-
-        # Allow overriding model specifics (model, model wrapper, model endpoint IP + type, context_window)
-        if model and model != llm_config.model:
-            typer.secho(f"{CLI_WARNING_PREFIX}Overriding default model {llm_config.model} with {model}", fg=typer.colors.YELLOW)
-            llm_config.model = model
-        if context_window is not None and int(context_window) != llm_config.context_window:
-            typer.secho(
-                f"{CLI_WARNING_PREFIX}Overriding default context window {llm_config.context_window} with {context_window}",
-                fg=typer.colors.YELLOW,
-            )
-            llm_config.context_window = context_window
-        if model_wrapper and model_wrapper != llm_config.model_wrapper:
-            typer.secho(
-                f"{CLI_WARNING_PREFIX}Overriding existing model wrapper {llm_config.model_wrapper} with {model_wrapper}",
-                fg=typer.colors.YELLOW,
-            )
-            llm_config.model_wrapper = model_wrapper
-        if model_endpoint and model_endpoint != llm_config.model_endpoint:
-            typer.secho(
-                f"{CLI_WARNING_PREFIX}Overriding existing model endpoint {llm_config.model_endpoint} with {model_endpoint}",
-                fg=typer.colors.YELLOW,
-            )
-            llm_config.model_endpoint = model_endpoint
-        if model_endpoint_type and model_endpoint_type != llm_config.model_endpoint_type:
-            typer.secho(
-                f"{CLI_WARNING_PREFIX}Overriding existing model endpoint type {llm_config.model_endpoint_type} with {model_endpoint_type}",
-                fg=typer.colors.YELLOW,
-            )
-            llm_config.model_endpoint_type = model_endpoint_type
 
         # create agent
         client = create_client()
+
+        # choose from list of llm_configs
+        llm_configs = client.list_llm_configs()
+        llm_options = [llm_config.model for llm_config in llm_configs]
+        # select model
+        if len(llm_options) == 0:
+            raise ValueError("No LLM models found. Please enable a provider.")
+        elif len(llm_options) == 1:
+            llm_model_name = llm_options[0]
+        else:
+            llm_model_name = questionary.select("Select LLM model:", choices=llm_options).ask()
+        llm_config = [llm_config for llm_config in llm_configs if llm_config.model == llm_model_name][0]
+
+        # choose form list of embedding configs
+        embedding_configs = client.list_embedding_configs()
+        embedding_options = [embedding_config.embedding_model for embedding_config in embedding_configs]
+        # select model
+        if len(embedding_options) == 0:
+            raise ValueError("No embedding models found. Please enable a provider.")
+        elif len(embedding_options) == 1:
+            embedding_model_name = embedding_options[0]
+        else:
+            embedding_model_name = questionary.select("Select embedding model:", choices=embedding_options).ask()
+        embedding_config = [
+            embedding_config for embedding_config in embedding_configs if embedding_config.embedding_model == embedding_model_name
+        ][0]
+
         human_obj = client.get_human(client.get_human_id(name=human))
         persona_obj = client.get_persona(client.get_persona_id(name=persona))
         if human_obj is None:

letta/cli/cli_config.py

@@ -35,8 +35,6 @@ from letta.local_llm.constants import (
     DEFAULT_WRAPPER_NAME,
 )
 from letta.local_llm.utils import get_available_wrappers
-from letta.schemas.embedding_config import EmbeddingConfig
-from letta.schemas.llm_config import LLMConfig
 from letta.server.utils import shorten_key_middle
 
 app = typer.Typer()
@@ -71,7 +69,7 @@ def configure_llm_endpoint(config: LettaConfig, credentials: LettaCredentials):
     model_endpoint_type, model_endpoint = None, None
 
     # get default
-    default_model_endpoint_type = config.default_llm_config.model_endpoint_type if config.default_embedding_config else None
+    default_model_endpoint_type = None
     if (
         config.default_llm_config
         and config.default_llm_config.model_endpoint_type is not None
@@ -126,7 +124,41 @@ def configure_llm_endpoint(config: LettaConfig, credentials: LettaCredentials):
         model_endpoint = questionary.text("Override default endpoint:", default=model_endpoint).ask()
         if model_endpoint is None:
             raise KeyboardInterrupt
-        provider = "openai"
+
+    elif provider == "groq":
+        groq_user_msg = "Enter your Groq API key (starts with 'gsk-', see https://console.groq.com/keys):"
+        # check for key
+        if credentials.groq_key is None:
+            # allow key to get pulled from env vars
+            groq_api_key = os.getenv("GROQ_API_KEY", None)
+            # if we still can't find it, ask for it as input
+            if groq_api_key is None:
+                while groq_api_key is None or len(groq_api_key) == 0:
+                    # Ask for API key as input
+                    groq_api_key = questionary.password(groq_user_msg).ask()
+                    if groq_api_key is None:
+                        raise KeyboardInterrupt
+            credentials.groq_key = groq_api_key
+            credentials.save()
+        else:
+            # Give the user an opportunity to overwrite the key
+            default_input = shorten_key_middle(credentials.groq_key) if credentials.groq_key.startswith("gsk-") else credentials.groq_key
+            groq_api_key = questionary.password(
+                groq_user_msg,
+                default=default_input,
+            ).ask()
+            if groq_api_key is None:
+                raise KeyboardInterrupt
+            # If the user modified it, use the new one
+            if groq_api_key != default_input:
+                credentials.groq_key = groq_api_key
+                credentials.save()
+
+        model_endpoint_type = "groq"
+        model_endpoint = "https://api.groq.com/openai/v1"
+        model_endpoint = questionary.text("Override default endpoint:", default=model_endpoint).ask()
+        if model_endpoint is None:
+            raise KeyboardInterrupt
 
     elif provider == "azure":
         # check for necessary vars
@@ -392,6 +424,12 @@ def get_model_options(
             fetched_model_options = cohere_get_model_list(url=model_endpoint, api_key=credentials.cohere_key)
             model_options = [obj for obj in fetched_model_options]
 
+        elif model_endpoint_type == "groq":
+            if credentials.groq_key is None:
+                raise ValueError("Missing Groq API key")
+            fetched_model_options_response = openai_get_model_list(url=model_endpoint, api_key=credentials.groq_key, fix_url=True)
+            model_options = [obj["id"] for obj in fetched_model_options_response["data"]]
+
         else:
             # Attempt to do OpenAI endpoint style model fetching
             # TODO support local auth with api-key header
@@ -555,10 +593,32 @@ def configure_model(config: LettaConfig, credentials: LettaCredentials, model_en
                 if model is None:
                     raise KeyboardInterrupt
 
+    # Groq support via /chat/completions + function calling endpoints
+    elif model_endpoint_type == "groq":
+        try:
+            fetched_model_options = get_model_options(
+                credentials=credentials, model_endpoint_type=model_endpoint_type, model_endpoint=model_endpoint
+            )
+
+        except Exception as e:
+            # NOTE: if this fails, it means the user's key is probably bad
+            typer.secho(
+                f"Failed to get model list from {model_endpoint} - make sure your API key and endpoints are correct!", fg=typer.colors.RED
+            )
+            raise e
+
+        model = questionary.select(
+            "Select default model:",
+            choices=fetched_model_options,
+            default=fetched_model_options[0],
+        ).ask()
+        if model is None:
+            raise KeyboardInterrupt
+
     else:  # local models
 
         # ask about local auth
-        if model_endpoint_type in ["groq"]:  # TODO all llm engines under 'local' that will require api keys
+        if model_endpoint_type in ["groq-chat-compltions"]:  # TODO all llm engines under 'local' that will require api keys
             use_local_auth = True
             local_auth_type = "bearer_token"
             local_auth_key = questionary.password(
@@ -779,7 +839,7 @@ def configure_model(config: LettaConfig, credentials: LettaCredentials, model_en
 def configure_embedding_endpoint(config: LettaConfig, credentials: LettaCredentials):
     # configure embedding endpoint
 
-    default_embedding_endpoint_type = config.default_embedding_config.embedding_endpoint_type if config.default_embedding_config else None
+    default_embedding_endpoint_type = None
 
     embedding_endpoint_type, embedding_endpoint, embedding_dim, embedding_model = None, None, None, None
     embedding_provider = questionary.select(
@@ -844,9 +904,7 @@ def configure_embedding_endpoint(config: LettaConfig, credentials: LettaCredenti
                 raise KeyboardInterrupt
 
         # get model type
-        default_embedding_model = (
-            config.default_embedding_config.embedding_model if config.default_embedding_config else "BAAI/bge-large-en-v1.5"
-        )
+        default_embedding_model = "BAAI/bge-large-en-v1.5"
         embedding_model = questionary.text(
             "Enter HuggingFace model tag (e.g. BAAI/bge-large-en-v1.5):",
             default=default_embedding_model,
@@ -855,7 +913,7 @@ def configure_embedding_endpoint(config: LettaConfig, credentials: LettaCredenti
             raise KeyboardInterrupt
 
         # get model dimentions
-        default_embedding_dim = config.default_embedding_config.embedding_dim if config.default_embedding_config else "1024"
+        default_embedding_dim = "1024"
         embedding_dim = questionary.text("Enter embedding model dimentions (e.g. 1024):", default=str(default_embedding_dim)).ask()
         if embedding_dim is None:
             raise KeyboardInterrupt
@@ -880,9 +938,7 @@ def configure_embedding_endpoint(config: LettaConfig, credentials: LettaCredenti
                 raise KeyboardInterrupt
 
         # get model type
-        default_embedding_model = (
-            config.default_embedding_config.embedding_model if config.default_embedding_config else "mxbai-embed-large"
-        )
+        default_embedding_model = "mxbai-embed-large"
         embedding_model = questionary.text(
             "Enter Ollama model tag (e.g. mxbai-embed-large):",
             default=default_embedding_model,
@@ -891,7 +947,7 @@ def configure_embedding_endpoint(config: LettaConfig, credentials: LettaCredenti
             raise KeyboardInterrupt
 
         # get model dimensions
-        default_embedding_dim = config.default_embedding_config.embedding_dim if config.default_embedding_config else "512"
+        default_embedding_dim = "512"
         embedding_dim = questionary.text("Enter embedding model dimensions (e.g. 512):", default=str(default_embedding_dim)).ask()
         if embedding_dim is None:
             raise KeyboardInterrupt
@@ -1040,19 +1096,6 @@ def configure():
 
     # TODO: remove most of this (deplicated with User table)
     config = LettaConfig(
-        default_llm_config=LLMConfig(
-            model=model,
-            model_endpoint=model_endpoint,
-            model_endpoint_type=model_endpoint_type,
-            model_wrapper=model_wrapper,
-            context_window=context_window,
-        ),
-        default_embedding_config=EmbeddingConfig(
-            embedding_endpoint_type=embedding_endpoint_type,
-            embedding_endpoint=embedding_endpoint,
-            embedding_dim=embedding_dim,
-            embedding_model=embedding_model,
-        ),
         # storage
         archival_storage_type=archival_storage_type,
         archival_storage_uri=archival_storage_uri,