GitHub

embedding_model

API reference for embedding_model.

An EmbeddingModel over an OpenAI-compatible Embeddings API (Effect's OpenAiEmbeddingModel in @effect/ai-openai-compat)::

program.pipe(fx.provide(embedding_model.model("text-embedding-3-small", dimensions=1536).layer))

Re-exports

Types

TypeDefinitionDescription
ModelConfigtype ModelConfig = ConfigService | Mapping[str, Any]

Classes

Functions

provider_response

provider_response(count, response) -> Effect[em.ProviderResponse, AiError]

The vectors in input order; a missing, duplicate, out-of-range or non-vector entry fails.

ParameterTypeDescription
countint
responseW.EmbeddingResponse

Returns Effect[em.ProviderResponse, AiError]

def provider_response(
    count: int, response: W.EmbeddingResponse
) -> Effect[em.ProviderResponse, AiError]:
    """The vectors in input order; a missing, duplicate, out-of-range or
    non-vector entry fails."""
    data = response["data"]
    if len(data) != count:
        return _invalid(f"Provider returned {len(data)} embeddings but expected {count}")
    results: list[list[float]] = [[] for _ in range(count)]
    seen: set[int] = set()
    for entry in data:
        index = entry["index"]
        if not 0 <= index < count:
            return _invalid(f"Provider returned invalid embedding index: {index}")
        if index in seen:
            return _invalid(f"Provider returned duplicate embedding index: {index}")
        vector = entry["embedding"]
        if isinstance(vector, str):
            return _invalid(f"Provider returned non-vector embedding at index {index}")
        seen.add(index)
        results[index] = list(vector)
    usage = response.get("usage")
    return fx.succeed(
        em.ProviderResponse(results, None if usage is None else usage["prompt_tokens"])
    )

make

make(*, model, config=None) -> Effect[em.Service, Never, OpenAiClient]
ParameterTypeDescription
modelstr
configModelConfig | None = None

Returns Effect[em.Service, Never, OpenAiClient]

def make(
    *, model: str, config: ModelConfig | None = None
) -> Effect[em.Service, Never, OpenAiClient]:
    def build(client: ClientService) -> Effect[em.Service]:
        def embed_many(options: em.ProviderOptions) -> Effect[em.ProviderResponse, AiError]:
            return (
                P.current_config(Config, {"model": model}, config)
                .flat_map(
                    lambda cfg: client.create_embedding({**cfg, "input": list(options.inputs)})
                )
                .flat_map(lambda response: provider_response(len(options.inputs), response))
            )

        return em.make(embed_many=embed_many, batch_key=_batch_key)

    return OpenAiClient().flat_map(build)

layer

layer(*, model, config=None) -> L.Layer[em.EmbeddingModel, Never, OpenAiClient]
ParameterTypeDescription
modelstr
configModelConfig | None = None

Returns L.Layer[em.EmbeddingModel, Never, OpenAiClient]

def layer(
    *, model: str, config: ModelConfig | None = None
) -> L.Layer[em.EmbeddingModel, Never, OpenAiClient]:
    return L.effect(em.EmbeddingModel, make(model=model, config=config))

model

model(model, *, dimensions, config=None) -> M.Model[em.EmbeddingModel | em.Dimensions, OpenAiClient]

The model and its Dimensions as a Model (provider "openai").

ParameterTypeDescription
modelstr
dimensionsint
configModelConfig | None = None

Returns M.Model[em.EmbeddingModel | em.Dimensions, OpenAiClient]

def model(
    model: str, *, dimensions: int, config: ModelConfig | None = None
) -> M.Model[em.EmbeddingModel | em.Dimensions, OpenAiClient]:
    """The model and its ``Dimensions`` as a ``Model`` (provider
    ``"openai"``)."""
    merged = {**(config or {}), "dimensions": dimensions}
    return M.make(
        "openai",
        model,
        L.merge(layer(model=model, config=merged), L.succeed(em.Dimensions, dimensions)),
    )

with_config_override

with_config_override(overrides) -> P.WithConfigOverride[ConfigService]

Run an effect with overrides merged over the current Config. Use with .pipe.

ParameterTypeDescription
overridesConfigService

Returns P.WithConfigOverride[ConfigService]

def with_config_override(overrides: ConfigService) -> P.WithConfigOverride[ConfigService]:
    """Run an effect with ``overrides`` merged over the current ``Config``.
    Use with ``.pipe``."""
    return P.WithConfigOverride(Config, overrides)