Skip to main content

vv-llm

中文文档

Universal LLM interface layer for Python. One API, 17 backends, sync & async.

Requires Python 3.11 or newer.

pip install vv-llm

Supported Backends

OpenAI | Anthropic | DeepSeek | Gemini | Qwen | Groq | Mistral | Moonshot | MiniMax | Yi | ZhiPuAI | Baichuan | StepFun | xAI | Xiaomi | Ernie | Local

Also supports Azure OpenAI, Vertex AI, and AWS Bedrock deployments.

Quick Start

Configure

from vv_llm.settings import settings

settings.load({
    "endpoints": [
        {
            "id": "openai-default",
            "api_base": "https://api.openai.com/v1",
            "api_key": "sk-...",
        }
    ],
    "backends": {
        "openai": {
            "models": {
                "gpt-4o": {
                    "id": "gpt-4o",
                    "endpoints": ["openai-default"],
                }
            }
        }
    }
})

Typed sync (canonical request)

from vv_llm.chat_clients import create_chat_client, BackendType
from vv_llm import ChatRequest, ChatRequestOptions, ThinkingPreference

client = create_chat_client(BackendType.OpenAI, model="gpt-4o")
resp = client.create(
    ChatRequest(
        model="gpt-4o",
        messages=[{"role": "user", "content": "Explain RAG in one sentence"}],
        options=ChatRequestOptions(
            thinking=ThinkingPreference.default(),
            max_tokens=512,
        ),
    )
)
print(resp.content)

ChatRequest is the normalized runtime request. At a contract boundary, ChatRequest.from_contract(...) decodes canonical JSON (where model is required and options.stream is nested), while to_contract() omits runtime transport controls such as headers and query parameters.

Use ThinkingPreference.default() to preserve the provider default, enabled() or enabled(budget_tokens=...) to opt in, and disabled() to opt out explicitly.

Keyword API

create_completion(...) accepts keyword arguments. Pass thinking explicitly when a provider supports Anthropic-style thinking control; omit it to use the provider default:

resp = client.create_completion(
    messages=[{"role": "user", "content": "Answer directly"}],
    thinking={"type": "disabled"},
)

Middleware, Retry, And Metadata

Wrap a client with MiddlewareChatClient for middleware hooks, classified retry, and execution metadata:

from vv_llm import ChatMiddlewareV1, ChatRequest, MiddlewareChatClient, RetryPolicy

class TraceMiddleware(ChatMiddlewareV1):
    def on_request(self, context, request):
        context.attributes["trace_id"] = "request-42"
        return request

runtime = MiddlewareChatClient(
    client,
    [TraceMiddleware()],
    retry_policy=RetryPolicy(max_attempts=3, total_timeout=20),
)
result = runtime.create_with_metadata(
    ChatRequest(messages=[{"role": "user", "content": "Answer directly"}])
)

print(result.response.content)
print(result.metadata.provider, result.metadata.attempts, result.metadata.latency_ms)

ErrorKind distinguishes authentication, rate limiting, network, timeout, invalid request, context length, content policy, missing model, provider internal, serialization, and configuration failures. The default retry policy retries only transient kinds and respects retry-after-ms plus numeric or HTTP-date Retry-After, exponential backoff, jitter, and an optional total deadline.

Explicit Registry And Fallback

Fallback is opt-in and ordered. Every registration declares model capabilities, so an incompatible route is skipped without sending a request:

from vv_llm import FallbackChatClient, FallbackRoute, ProviderRegistry

registry = ProviderRegistry()
registry.register(
    "primary",
    lambda: primary_client,
    capabilities=primary_client.capabilities,
)
registry.register(
    "secondary",
    lambda: secondary_client,
    capabilities=secondary_client.capabilities,
)
runtime = FallbackChatClient(
    registry,
    [
        FallbackRoute("primary", "primary-model"),
        FallbackRoute("secondary", "secondary-model"),
    ],
)

Authentication and invalid-request errors do not fall back by default. Streaming may switch routes only while establishing the stream or before its first visible chunk; after output begins, later errors are returned without replay.

Streaming

from vv_llm import ChatRequest

for chunk in client.create(ChatRequest(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Write a haiku"}],
    stream=True,
)):
    if chunk.content:
        print(chunk.content, end="")

Async

import asyncio
from vv_llm.chat_clients import create_async_chat_client, BackendType
from vv_llm import ChatRequest

async def main():
    client = create_async_chat_client(BackendType.OpenAI, model="gpt-4o")
    resp = await client.create(ChatRequest(
        model="gpt-4o",
        messages=[{"role": "user", "content": "hello"}],
    ))
    print(resp.content)

asyncio.run(main())

HTTP transport clients

The http_client argument accepts httpx2.Client for sync calls and httpx2.AsyncClient for async calls. This lets applications provide a custom transport (for example, an offline MockTransport) while keeping OpenAI and Anthropic SDK clients on the same HTTPX2 runtime:

import httpx2
from vv_llm.chat_clients import BackendType, create_chat_client

transport = httpx2.MockTransport(
    lambda request: httpx2.Response(200, json={"choices": []}, request=request)
)
http_client = httpx2.Client(transport=transport)
client = create_chat_client(BackendType.OpenAI, model="gpt-4o", http_client=http_client)

Use an endpoint proxy setting when vv-llm should construct the transport client itself. Legacy httpx.Client and httpx.AsyncClient instances are not accepted; use the matching HTTPX2 client type instead.

Embedding & Rerank

from vv_llm.settings import settings

settings.load({
    "endpoints": [
        {
            "id": "siliconflow",
            "api_base": "https://api.siliconflow.cn/v1",
            "api_key": "sk-...",
        }
    ],
    "backends": {},
    "embedding_backends": {
        "siliconflow": {
            "models": {
                "BAAI/bge-large-zh-v1.5": {
                    "id": "BAAI/bge-large-zh-v1.5",
                    "endpoints": ["siliconflow"],
                    "protocol": "openai_embeddings",
                }
            }
        }
    },
    "rerank_backends": {
        "siliconflow": {
            "models": {
                "BAAI/bge-reranker-v2-m3": {
                    "id": "BAAI/bge-reranker-v2-m3",
                    "endpoints": ["siliconflow"],
                    "protocol": "custom_json_http",
                    "request_mapping": {
                        "method": "POST",
                        "path": "/rerank",
                        "body_template": {
                            "model": "${model_id}",
                            "query": "${query}",
                            "documents": "${documents}",
                        },
                    },
                    "response_mapping": {
                        "results_path": "$.results[*]",
                        "field_map": {
                            "index": "$.index",
                            "relevance_score": "$.relevance_score",
                        },
                    },
                }
            }
        }
    },
})
from vv_llm.embedding_clients import create_embedding_client
from vv_llm.rerank_clients import create_rerank_client

embedding_client = create_embedding_client("siliconflow", model="BAAI/bge-large-zh-v1.5")
embedding_resp = embedding_client.create_embeddings(input="hello world")
print(len(embedding_resp.data[0].embedding))

rerank_client = create_rerank_client("siliconflow", model="BAAI/bge-reranker-v2-m3")
rerank_resp = rerank_client.rerank(
    query="Apple",
    documents=["apple", "banana", "fruit", "vegetable"],
)
print(rerank_resp.results[0].index, rerank_resp.results[0].relevance_score)
import asyncio
from vv_llm.embedding_clients import create_async_embedding_client
from vv_llm.rerank_clients import create_async_rerank_client

async def main():
    embedding_client = create_async_embedding_client("siliconflow", model="BAAI/bge-large-zh-v1.5")
    rerank_client = create_async_rerank_client("siliconflow", model="BAAI/bge-reranker-v2-m3")

    emb = await embedding_client.create_embeddings(input=["a", "b"])
    rr = await rerank_client.rerank(query="Apple", documents=["apple", "banana"])
    print(len(emb.data), len(rr.results))

asyncio.run(main())

Reasoning effort

Model capabilities expose reasoning_efforts: omitted/null means unknown, [] means unsupported, and a list declares effective choices. Unspecified effort uses the provider default; none is an explicit model-dependent value.

Select a different model through the request model or an endpoint binding's model_id. A conflicting extra_body.model is rejected even with passthrough.

Use client.create(request, capability_policy=CapabilityPolicy.STRICT) or client.create_completion(..., capability_policy=CapabilityPolicy.STRICT) for validation before sending. The default is WARN; PASSTHROUGH skips model support checks. Conflicting controls still fail. Responses maps effort to reasoning.effort and Anthropic maps it to output_config.effort.

Endpoint binding capabilities partially override model metadata; lists replace inherited lists. Registry model_capabilities supplies per-model fallback metadata. Each route preserves the requested effort and skips incompatible models.

Existing keyword and typed calls remain valid. Leaving effort unspecified still uses the provider default. Calls that previously sent an unrecognized value can now emit a warning under the default policy; opting into strict validation rejects both unsupported values and unknown model support before a provider request. This applies to sync/async and completion/streaming paths.

After configuring a DeepSeek Flash endpoint binding:

from vv_llm import CapabilityPolicy, ChatRequest, ChatRequestOptions
from vv_llm.chat_clients import BackendType, create_chat_client

client = create_chat_client(BackendType.DeepSeek, model="deepseek-flash")
print(client.capabilities.reasoning_efforts)
print(client.capabilities.reasoning_effort_aliases)

response = client.create(
    ChatRequest(
        model=client.model,
        messages=[{"role": "user", "content": "Compute 37 * 19."}],
        options=ChatRequestOptions(reasoning_effort="xhigh", max_tokens=256),
    ),
    capability_policy=CapabilityPolicy.STRICT,
)
# The provider receives xhigh unchanged; its documented effective target is high.

The keyword API uses the same policy and model-specific validation:

response = client.create_completion(
    messages=[{"role": "user", "content": "Compute 37 * 19."}],
    reasoning_effort="high",
    capability_policy=CapabilityPolicy.STRICT,
    max_tokens=256,
)

Use effective choices for a model selector; compatibility aliases are additional accepted inputs, not separate intensities. An included none is an explicit off control. Effort omission does not enable or disable thinking: use ThinkingPreference for that separate model capability. GLM-5.3/FLASH reject xhigh in strict mode and require thinking; GLM-5.2 permits explicit disabled thinking. In the recorded GLM-5.2 live checks, none/minimal still returned reasoning content, while explicit disabled thinking did not.

Offline capabilities/validation/fallback and configured effort/thinking/streaming examples are described in the examples guide.

reasoning_effort_aliases maps documented compatibility inputs to effective choices. Aliases are accepted only when their target remains in reasoning_efforts; requests retain the original input. Both lists and alias maps on bindings replace inherited fields. DeepSeek exposes low/high/max, plus none for off, with minimal → low, medium/xhigh → high and ultra → max. Aliases are not extra selectable intensities.

Features

  • Unified interface — canonical ChatRequest execution across all providers, with create_completion / create_stream retained for compatibility
  • Embedding & rerank — unified sync/async retrieval clients with normalized outputs
  • Type-safe factory — create_chat_client(BackendType.X) returns the correct client type
  • Multi-endpoint — select enabled endpoints by ascending priority, preserving configuration order within each tier
  • Tool calling — normalized tool/function calling across providers
  • Multimodal — text + image inputs where supported
  • Thinking/reasoning — access chain-of-thought from Claude, DeepSeek Reasoner, etc.
  • Token counting — per-model tokenizers (tiktoken, deepseek-tokenizer, qwen-tokenizer)
  • Rate limiting — RPM/TPM controls with memory, Redis, or DiskCache backends
  • Context length control — automatic message truncation to fit model limits
  • Prompt caching — Anthropic prompt caching support
  • Retry with backoff — configurable retry logic for transient failures
  • Versioned middleware — stable v1 request, response, and error hooks outside provider adapters
  • Classified errors — provider-neutral error kinds with retryability and request context
  • Explicit fallback — registered, ordered, capability-aware routes with no hidden provider switching
  • Scripted testing — deterministic completion/error/stream scripts for conformance tests

Model endpoint bindings accept an optional priority integer of at least 1 (default: 1). Explicit endpoint_id selection takes precedence. from vv_llm.settings import order_endpoints exposes the same stable ordering: order_endpoints(endpoints, preferred_endpoint_id=None) returns a new list. A preferred endpoint moves ahead only within its priority tier.

This working tree includes the locally validated, unpublished vv-llm-contract 1.3.6 candidate. Read contract metadata, the model catalog, and integrity status through vv_llm.contract:

from vv_llm.contract import contract_info, load_catalog, verify_contract

info = contract_info()
assert info.contract_version == "1.3.6"
assert verify_contract().ok
catalog = load_catalog()

Maintainers can validate the packaged copy with pdm run contract-check and update it from a verified release directory with pdm run contract-sync --source PATH.

Finish and refusal evidence (0.10.1)

Native Anthropic and all OpenAI-compatible chat clients (including Gemini and Local) expose optional response.metadata and chunk.metadata, reusing ResponseMetadata. Sync and async calls use the same fields:

Field Meaning
finish_reason Original provider finish/stop reason; for Responses, incomplete_details.reason when present, otherwise status
finish_reason_normalized stop, length, tool_calls, content_filter, refusal, other, or None when absent
refusal Explicit provider refusal text, concatenated in stream order; no text is inferred from a reason or ordinary answer
stream_terminated True for an observed terminal signal; False when none was observed with observation available; None for non-streaming or degraded/unavailable observation without another terminal signal
stream_exhausted True after normal iterator exhaustion; false during iteration, early close, or a stream error; None for non-streaming
termination_signals Observed signals such as finish_reason, [DONE], message_delta.stop_reason, message_stop, or response.completed / response.incomplete / response.failed
stream = client.create_stream(messages=[{"role": "user", "content": "Hello"}])
for chunk in stream:
    print(chunk.content or "", end="")
evidence = stream.metadata  # available even when no chunks were emitted
print(evidence.finish_reason, evidence.refusal, evidence.stream_terminated)

Async callers use stream = await client.create_stream(...) and async for. The return object retains the generator protocol (send/throw/close, or asend/athrow/aclose) and adds metadata; it is no longer a native Python generator object. Each chunk references the stream's live, shared metadata. Read or serialize stream.metadata after fully consuming the iterator: a dump made inside the loop cannot include later signals. No terminal chunk is added and no content is buffered to wait for one. Middleware and fallback create_with_metadata() retain this same evidence object. Buffered fallback replay starts unexhausted and becomes exhausted only when the caller finishes replay. Async adapters await closure of their owned SDK stream on close, throw, cancellation, and async-generator finalization (GC requires a running event loop).

stream_terminated starts at False. During iteration, degradation immediately changes it to None unless a terminal signal was already observed. Any observed terminal signal sets it to True, including signals arriving after degradation; later degradation never clears True. These live values are provisional until the stream is fully consumed. stream_exhausted=True with stream_terminated=False records EOF without a terminal signal and without observation degradation; with stream_terminated=None, termination is unknown. A terminal signal alone says nothing about successful output: length limits, filtering, refusal, and Responses failure can also terminate a stream. Unknown reasons remain unmodified and normalize to other; missing reasons stay None. Anthropic stop_reason="refusal" normalizes to refusal without inventing refusal text. model_context_window_exceeded normalizes to length; pause_turn stays other. Responses also retain status, incomplete_details, and error in metadata.attributes. Chat Completions finish/refusal evidence selects choice index 0, regardless of array position. If a provider omits all choice indices, evidence falls back to the first array item. The existing content adapter still reads the first array item; this does not add multi-choice content aggregation. OpenAI [DONE] observation taps the SDK's internal SSE decoder only when its interface is recognized. Unknown interfaces remain untouched; a warning and metadata.attributes["openai_done_observer"] diagnostic (unsupported_stream, unsupported_decoder, or observation_failed) report reduced observation. In 0.10.1, after degradation, stream_terminated remains None even after normal exhaustion unless another signal such as finish_reason establishes True. A DONE-only stream can therefore finish with unknown termination evidence. Observer failures do not interrupt SDK consumption; SDK network/parse errors still propagate, without replaying the request. MockTransport and loopback tests cover sync/async interface drift.

This is Python runtime metadata, separate from the vendored 1.3.6 canonical response JSON. model_dump() is not a canonical response encoder. Portable integrations can explicitly put a metadata dump in an existing x_* extension (for example x_response_metadata); no schema, fixture, catalog, lock, or contract revision is changed.

Python Capability Matrix

Surface Python support Boundary
Middleware MiddlewareChatClient and AsyncMiddlewareChatClient; v1 request/response/error hooks and metadata Opt-in wrapper around a chat client
Fallback FallbackChatClient and AsyncFallbackChatClient; ordered, capability-aware routes Stream fallback is limited to setup/before the first visible chunk
Retry RetryPolicy plus sync/async executors; classified transient errors, Retry-After, backoff, jitter, deadline Authentication and invalid-request errors are not retried by default
Deterministic testing Scripted clients, vendored protocol fixtures, and unit tests No network access; live checks require explicit opt-in
Chat providers Anthropic native adapter; 15 OpenAI-compatible adapters; Local adapter Sync/async and streaming are normalized; tools, structured output, multimodal input, and thinking remain model/provider dependent
Embedding Sync/async configured clients openai_embeddings, SiliconFlow, Cohere, Voyage, and custom JSON HTTP protocols
Rerank Sync/async configured clients OpenAI-compatible, Cohere, Jina, Voyage, SiliconFlow, and custom JSON HTTP protocols

Chat Provider Matrix

Adapter Providers Transport and common behavior
Native Anthropic Native sync/async chat, streaming, tools, vision, thinking, and prompt-cache handling
OpenAI-compatible OpenAI, DeepSeek, Gemini, Groq, MiniMax, Mistral, Moonshot, Qwen, Yi, ZhiPuAI, Baichuan, StepFun, xAI, Xiaomi, Ernie Shared sync/async request and stream normalization; actual tools, structured output, multimodal, and reasoning support follows the vendored model catalog and provider endpoint
Local Local Same configured adapter shape for sync/async and streaming; endpoint behavior is deployment-specific

Examples

Runnable examples are in examples/: basic_chat.py, streaming.py, tools.py, multimodal.py, and contract_json.py cover the main typed request paths. async_streaming.py, typed_thinking.py, middleware_metadata.py, and registry_fallback.py cover focused extensions; the last one is deterministic and offline. reasoning_capabilities.py is also offline; reasoning_effort.py sends one configured request with optional streaming.

Cache Usage Semantics

OpenAI-compatible chat completions report cache reads through usage.prompt_tokens_details.cached_tokens. usage.prompt_tokens remains the total input token count, so consumers can calculate uncached input as prompt_tokens - cached_tokens. This path intentionally does not populate Anthropic's cache_read_input_tokens field because Anthropic defines its base input_tokens as uncached input.

For generic OpenAI-compatible backends, omitted cache-read fields remain unknown, while an explicit cached_tokens: 0 is preserved as an observed zero. Moonshot may omit both top-level cached_tokens and prompt_tokens_details on a cold request; only in that fully omitted case does vv-llm project prompt_tokens_details.cached_tokens = 0 from the provider contract. Explicit null or invalid cache values remain unknown.

Utilities

from vv_llm.chat_clients import format_messages, get_token_counts, get_message_token_counts
Function Description
format_messages Normalize multimodal/tool messages across formats
get_token_counts Count tokens for a text string
get_message_token_counts Count tokens for a message list

Optional Dependencies

pip install 'vv-llm[redis]'      # Redis rate limiting
pip install 'vv-llm[diskcache]'  # DiskCache rate limiting
pip install 'vv-llm[server]'     # FastAPI token server
pip install 'vv-llm[vertex]'     # Google Vertex AI
pip install 'vv-llm[bedrock]'    # AWS Bedrock

Project Structure

src/vv_llm/
  _contract/      # Versioned schemas, fixtures, catalog, and consumer lock
  chat_clients/    # Per-backend clients + factory
  embedding_clients/  # Embedding clients + factory
  rerank_clients/     # Rerank clients + factory
  retrieval_clients/  # Shared retrieval client internals
  settings/        # Configuration management
  types/           # Type definitions & enums
  utilities/       # Rate limiting, retry, media processing, token counting
  server/          # Optional token counting server

tests/unit/        # Unit tests
tests/live/        # Live integration tests (requires real API keys)

User, Maintainer, And Release Workflows

Users

Install the package and configure endpoints through the public Settings API. Contract artifacts are read from the installed package; no repository checkout or local path is required at runtime.

Maintainers

pdm install -d          # Install dev dependencies
pdm run contract-check  # Validate only the vendored contract lock
pdm run contract-sync --source PATH  # Refresh from an explicit source tree
# Or: VV_LLM_CONTRACT_SOURCE=PATH pdm run contract-sync
# Compare an explicit source tree with the vendor:
python scripts/sync_contract.py --check --source PATH
pdm run lint            # Ruff linter
pdm run format-check    # Ruff format check
pdm run type-check      # Ty type checker
pdm run test            # Unit tests

For an intentional live smoke check, provide private settings through the existing tests/dev_settings.py mechanism and opt in explicitly:

VV_LLM_RUN_LIVE_TESTS=1 python tests/live/run_live_tests.py test_deepseek_contract_smoke.py

The smoke output contains only provider/model, response shape, usage counters, and exit status; it does not print credentials or response content.

Reasoning effort live checks

For an opt-in transport smoke using an explicit private settings file:

python tests/live/reasoning_effort_smoke.py --settings /secure/path/llm_settings.json \
  --backend deepseek --aliases --invalid-probe --limit 18

The smoke tests each declared value on credentialed model/transport routes, up to 80 requests by default. --aliases includes compatibility inputs; --invalid-probe tests an invalid value; --model backend:model selects a model; --report saves sanitized observations. --include-catalog opts into default-endpoint bindings absent from the local model list. Acceptance alone does not prove intensity behavior. The SDK timeout is configured per request, not a total wall-clock limit. See the recorded live results.

Release publishers

pdm build
python scripts/smoke_wheel.py

The release CI performs contract-check, unit tests, linting, package build, and isolated wheel smoke before publication. Live API checks are intentionally not part of release CI.

License

MIT

Gemini generation parameters

For Gemini 3 and later, chat adapters omit temperature, top_p, top_k, and thinking_budget (including camelCase spellings and nested provider overrides). Budget-only requests use the model default; no numeric budget-to-level mapping is inferred. Use reasoning_effort or Google thinking_config.thinking_level for explicit control, but not both. Gemini 3.7 Flash and 3.8 Flash expose low/medium/high; minimal is unsupported. Gemini 2.5 retains its budget and sampling behavior. Input objects are not mutated.

Decisions

Decision clients are independent from chat, embedding, and rerank clients. They use decision_backends and the same endpoint configuration. The pinned catalog declares gpt-6-luna support for predicate, choice, and score questions.

from vv_llm import create_decision_client, DecisionRequest, PredicateQuestion
from vv_llm.settings import settings

settings.load({
    "endpoints": [{"id": "openai", "api_base": "https://api.openai.com/v1", "api_key": "YOUR_KEY"}],
    "decision_backends": {"openai": {"default_endpoint": "openai"}},
})
with create_decision_client(model="gpt-6-luna") as client:
    result = client.create(DecisionRequest(
        input="The screen arrived broken.",
        questions=[PredicateQuestion(name="damaged", instructions="Does the customer report damage?")],
    ))

create_async_decision_client has the same request/response types. Responses preserve probabilities, score levels, per-question refusals, and token usage; callers choose thresholds. Only inline base64 image inputs are accepted. Unknown or unsupported decision capabilities fail before network access. Requests and responses expose from_contract/to_contract for portable JSON. The adapter uses the OpenAI SDK's generic POST method; no SDK upgrade or new dependency is needed.

Live smoke (requires an explicit local settings file and opt-in):

$env:VV_LLM_RUN_LIVE_TESTS = "1"
$env:VV_LLM_SETTINGS_JSON = "C:\secure\llm-settings.json"
python tests/live/test_decisions.py

Choice questions use choices; score questions use rubric and return score, confidence, and probabilities. Choice IDs can be strings or booleans.

Metadata

Release files for vv-llm 0.10.3

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for vv-llm 0.10.3
File Size Uploaded Provenance Actions
vv_llm-0.10.3.tar.gz 134.9 kB With provenance Details for vv_llm-0.10.3.tar.gz

Built distribution (wheel)

Table of built distributions (wheels) for vv-llm 0.10.3
File Interpreter ABI Platform Actions
vv_llm-0.10.3-py3-none-any.whl Python 3 none any Details for vv_llm-0.10.3-py3-none-any.whl

Total release size: 296.4 kB

Release files / vv_llm-0.10.3.tar.gz

Download URL vv_llm-0.10.3.tar.gz
Size 134.9 kB
Tags Source
SHA-256 checksum
How to use checksums
ae6e523faeb81c7cb595b69189c76c7d627cecb59e67b07eea79ebe94fc4ab59
BLAKE2b-256 checksum
How to use checksums
5605321f221a608a4c54abc23c4038b398418b692a7a4ff5441621cbd7c41a0a
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 10, 2026.

Transparency log

Release files / vv_llm-0.10.3-py3-none-any.whl

Download URL vv_llm-0.10.3-py3-none-any.whl
Size 161.6 kB
Tags Python 3
SHA-256 checksum
How to use checksums
cfdde6a84efb1b737e7b708679e5e09ec2b63978c790239a78088460a8b2b7e9
BLAKE2b-256 checksum
How to use checksums
c7194e3f52876a6b2c05348ef781cabb52de5f498b749e30da968f153772b4a4
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 10, 2026.

Transparency log

Security for vv-llm 0.10.3

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

Full provenance

Both files in this release have been uploaded with provenance metadata.

Select from 2 files

Attestation for vv_llm-0.10.3.tar.gz

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 10, 2026.

Transparency log

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Release history Release notifications | RSS feed

This release

0.10.3 This release

2 release files Full provenance

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page