This is a sentence-transformers model finetuned from Qwen/Qwen3-Embedding-0.6B. It maps sentences & paragraphs to a 1024-dimensional dense vector space and can be used for retrieval.

Model Details

Model Description

Model Type: Sentence Transformer
Base model: Qwen/Qwen3-Embedding-0.6B
Maximum Sequence Length: 32768 tokens
Output Dimensionality: 1024 dimensions
Similarity Function: Cosine Similarity
Supported Modality: Text

Model Sources

Documentation: Sentence Transformers Documentation
Repository: Sentence Transformers on GitHub
Hugging Face: Sentence Transformers on Hugging Face

Full Model Architecture

SentenceTransformer(
  (0): Transformer({'transformer_task': 'feature-extraction', 'modality_config': {'text': {'method': 'forward', 'method_output_name': 'last_hidden_state'}}, 'module_output_name': 'token_embeddings', 'architecture': 'Qwen3Model'})
  (1): Pooling({'embedding_dimension': 1024, 'pooling_mode': 'lasttoken', 'include_prompt': True})
  (2): Normalize({})
)

Usage

Direct Usage (Sentence Transformers)

First install the Sentence Transformers library:

pip install -U sentence-transformers

Then you can load this model and run inference.

python

from sentence_transformers import SentenceTransformer

# Download from the 🤗 Hub
model = SentenceTransformer("sentence_transformers_model_id")
# Run inference
queries = [
    'What are the steps to connect to the OCR Web Service using Membrane CLI?',
]
documents = [
    'The OCR Web Service is designed to transform images containing text into machine-readable text formats, facilitating automation in data entry and document processing for developers and businesses. Utilizing the OCR Web Service enables various applications such as extraction of text from scanned documents and images in formats like PDFs. The service operates using the Membrane CLI, which abstracts the complexities of authentication and credential management, enabling developers to focus on integration rather than authorization setups. \n\n### Installation and Setup\n\nTo start using the OCR Web Service, developers must first install the Membrane CLI:\n- **Command:** `npm install -g @membranehq/cli`  \nThis command installs the CLI globally, allowing the user to invoke it from any terminal session. \n\nAfter installation, the first-time setup of the CLI requires the user to log in by executing:\n- **Command:** `membrane login --tenant`  \nThis command will launch a browser for authentication. In headless environments, the user can copy a printed URL to perform the login and complete it with a command including a code provided post-authentication.\n\n### Connecting to the OCR Web Service\n\nTo connect to the OCR Web Service, developers can create a new connection by:\n1. Searching for the OCR Web Service connector with:\n   - **Command:** `membrane search ocr-web-service --elementType=connector --json`  \n   The response will contain details including the connector ID.\n2. Establishing a connection as follows:\n   - **Command:** `membrane connect --connectorId=CONNECTOR_ID --json`  \n   This command will require the user to authenticate via a browser, with the output providing a new connection ID. \n\n### Managing Connections\n\nTo verify existing connections:\n- **Command:** `membrane connection list --json`  \nThis will list all active connections and help identify if a previous OCR connection is established.\n\n### Searching and Running Actions\n\nFor querying available actions, users can execute:\n- **Command:** `membrane action list --intent=QUERY --connectionId=CONNECTION_ID --json`  \nThis command returns action objects containing IDs and input schemas necessary for executing tasks.\n\nTo run a specific action, the command is:\n- **Command:** `membrane action run --connectionId=CONNECTION_ID ACTION_ID --json`  \nParameters can be passed in JSON format using:\n- **Command:** `membrane action run --connectionId=CONNECTION_ID ACTION_ID --json --input "{ \\"key\\": \\"value\\" }"`\n\n### Proxying Requests\n\nIf pre-defined actions do not meet user needs, direct requests can be made to the OCR Web Service API via Membrane’s proxy:\n- **Command:** `membrane request CONNECTION_ID /path/to/endpoint`\nA range of options can be specified to modify the request, including HTTP method, headers, data payloads, and parameters via options flags.\n\n### Best Practices\n\nThe documentation emphasizes several best practices:\n- Rely on Membrane for interactions with external applications to leverage its built-in error handling, security, and token management features.\n- Explore available actions before attempting to create new API calls to save development time and prevent common mistakes.\n- Avoid asking users for API keys or credentials by managing authentication through Membrane directly.\n\nOverall, the OCR Web Service provides an encapsulated environment for efficiently handling image text extraction with robust support for ease of integration and security handling.',
    'The 2Captcha skill provides developers and businesses with a practical means of bypassing CAPTCHA challenges on various web and application platforms using a service that outsources the solving of these CAPTCHAs to human workers. The skill operates through Membrane CLI, which facilitates interaction with the 2Captcha service while automating authentication, credential refresh, and HTTP header management to simplify integration. The main features include support for different types of CAPTCHAs (Image, ReCaptchaV2, ReCaptchaV3, GeeTest, HCaptcha, Turnstile, MtCaptcha, KeyCaptcha, Text), making it versatile for varied use cases.\n\n### Workflow Steps and Control Flow\n1. **CLI Installation:** Users start by installing the Membrane CLI, which is required to run commands that interact with 2Captcha. This is done using `npm install -g @membranehq/cli`.\n2. **Authentication Setup:** First-time users authenticate through a browser using the command `membrane login --tenant`. In headless environments, a unique URL is provided for manual completion.\n3. **Creating a 2Captcha Connection:** Users create a connection to the 2Captcha service using a specific connector ID, retrieved from a search command. The command `membrane connect --connectorId=CONNECTOR_ID --json` initiates this connection process.\n4. **Managing Connections:** To check existing connections, the command `membrane connection list --json` is used which lists all established connections. Users can note the `connectionId` for further actions.\n5. **Searching Actions:** To discover available actions based on intent, users can run `membrane action list --intent=QUERY --connectionId=CONNECTION_ID --json`, which returns a list of action objects with their IDs and schemas.\n6. **Running Actions:** Actions are executed using the command `membrane action run --connectionId=CONNECTION_ID ACTION_ID --json`, during which JSON parameters can be passed for specific configurations.\n7. **Proxy Requests:** When built-in actions do not suffice, developers can directly interact with the 2Captcha API using `membrane request CONNECTION_ID /path/to/endpoint`, along with various flags for HTTP methods, headers, and body data.\n\n### Required Tools and Environment Assumptions\n- Node.js environment (for the installation of Membrane CLI).\n- Access to a web browser for initial authentication, unless operating in a headless environment where manual interaction is feasible.\n\n### Command-Line Usage and Argument Behavior\n- **CLI Commands:** Predominantly utilize `membrane` commands in the terminal.\n- **Arguments:** Various commands accept flags and JSON input. For example, `--json` denotes that input will be in JSON format, while others specify HTTP methods and query parameters.\n\n### Input/Output Contracts and Data Formats\n- Input should conform to JSON schemas outlined in action descriptions.\n- Output format for commands generally includes JSON responses detailing the results of operations, such as connection ids, action ids, and any errors encountered.\n\n### Operational Caveats and Limitations\n- The skill highly recommends the use of Membrane for API interactions to minimize the risk of errors in direct API calls.\n- It is advisable to search for pre-built actions before creating custom API calls, as Membrane accounts for pagination and possible edge cases in handling API communications.\n- Each action may incur token usage, which could be limited depending on the specifics of the Membrane and 2Captcha service agreements.',
    "The Server Health Skill is a command-line tool designed for quick server monitoring, providing insights into system statistics, processes, OpenClaw gateway information, and running services. It employs a script called `server-health.sh` that users can execute in their terminal. The tool offers various usage modes including standard view, verbose output, JSON format for automation, and alerts for warnings or errors based on system metrics.\n\n### Usage and Workflow\nUsers can run the script with different flags:\n- **Standard view**: `./server-health.sh` provides a basic overview of the server's status.\n- **Verbose mode**: `./server-health.sh --verbose` enriches the output by including additional details like temperature, network stats, swap usage, and I/O without requiring user interruptions.\n- **JSON output**: `./server-health.sh --json` sends output in JSON format, catering specifically to automation processes that require structured data handling.\n- **Alerts only**: `./server-health.sh --alerts` filters the output to show alerts related to resource usage (for instance, CPU, RAM, and disk thresholds).\n\n### Output Details\nThe outputs are structured into several sections:\n- **Always displayed** information includes system stats like CPU usage, RAM availability, disk usage, and server uptime. It lists the top processes by CPU and RAM consumption and shows the status and configuration of the OpenClaw gateway.\n- **Conditionally displayed** alerts trigger if resource usage exceeds predefined thresholds (i.e., disk >90%, RAM >80%, CPU >90%) or if swap space is in use.\n- **Verbose mode only** provides further details that can be vital for in-depth diagnostics like temperature readings (if sensor data is available), current network traffic, disk I/O rates, and specifics on running services.\n\n### Example Output\nAn example output provides a clear visual metric of server health, presenting the data in an easy-to-read style, spanning from general system health indicators to detailed process utilization and gateway status.\n\n### Operational Caveats and Limitations\nThis tool assumes a certain environment where the underlying system supports the required metrics (e.g., if temperature sensors are absent, temperature readings will not be shown). Additionally, monitoring accuracy depends on the correct configuration of the OpenClaw gateway and services like Docker and PostgreSQL that should be running on the system. The output formatting, especially in verbose mode, may depend on the terminal's capability to display special characters for better visualization.",
]
query_embeddings = model.encode_query(queries)
document_embeddings = model.encode_document(documents)
print(query_embeddings.shape, document_embeddings.shape)
# [1, 1024] [3, 1024]

# Get the similarity scores for the embeddings
similarities = model.similarity(query_embeddings, document_embeddings)
print(similarities)
# tensor([[0.7668, 0.4454, 0.2444]])

Training Details

Training Dataset

Unnamed Dataset

Size: 60,245 training samples
Columns: anchor, positive, and negative
Approximate statistics based on the first 1000 samples:
anchor positive negative
type string string string
details
min: 6 tokens
mean: 18.38 tokens
max: 60 tokens
min: 77 tokens
mean: 534.39 tokens
max: 1084 tokens
min: 84 tokens
mean: 605.13 tokens
max: 1068 tokens

Samples:

anchor	positive	negative
`How do I write a credential to a specific path in a .env file using the CLI?`	The Vincent skill is designed to securely manage various types of credentials required by applications, such as API keys, OAuth tokens, SSH keys, and structured username/password pairs. Its primary function is to create and store these credentials without exposing sensitive information in the context of the agent or in standard output. Instead, it utilizes a CLI tool, @vincentai/cli, to handle credential management directly and securely, which ensures that credential values are never printed or logged by the agent.

Workflow:

Creating a Secret: The agent initiates the process by running secret create with the --type CREDENTIALS argument, which generates a secret that is connected and secured through a unique keyId and a claimUrl, shared with the user for ownership claiming.
Setting Values: Users can set the credential values either directly through the Vincent dashboard (recommended) by claiming ownership using the provided claim URL, or via the CLI, which all... | DashPass is a service designed for securely managing and storing sensitive information, such as API keys, passwords, and other credentials, on the Dash blockchain—providing a decentralized alternative to traditional storage methods like [object Object] files. The core functionality revolves around a command-line interface (CLI) tool ([object Object]), which facilitates local encryption before any data is transmitted to the blockchain, ensuring that only the user with the correct private key can decrypt their credentials. This local encryption uses AES-256-GCM for each credential, maintaining high security throughout the process.


[object Object]

[object Object]: Credentials are inputted via standard input (stdin) and stored using the command [object Object], which accepts parameters for the service name, the type of credential (like API key), its sensitivity level, and a label. The command securely echoes the credential's va... | | What tokens does the wallet address 0x0000000000000000000000000000000000000001 hold, and what is their current market price? | The Query Address Info Skill is designed for querying on-chain wallet addresses to retrieve detailed information about token holdings. It encompasses functionalities that allow users to obtain a comprehensive list of tokens associated with a specific wallet address, along with pertinent metrics such as the current price of each token, the 24-hour percentage change in price, and the quantity held. The skill utilizes an API endpoint provided by Binance, structured specifically for accessing wallet token balances.


[object Object]

... |

The DeepBlue DeFi Research API is a public, read-only RESTful interface designed for retrieving real-time on-chain DeFi data specifically related to the Base blockchain. This API, developed by a team of four autonomous AI agents, provides various functionalities such as fetching current ETH prices from Chainlink, discovering trending pools on Base from GeckoTerminal, scoring tokens based on buy quality, and scanning wallet ERC20 holdings with USD evaluations. As a no-cost service, users can perform up to 10 requests per day without the need for authentication, making it accessible for quick reads on current DeFi data.


[object Object]


[object Object]

The API provides specific endpoints for each functionality, including fetching the ETH/USD price, discovering trending tokens/po... | | Can I generate a detailed report of my security metrics? | The VEXT Dashboard is a security aggregation tool specifically designed for use with an OpenClaw installation, bringing together various security data points into a unified report. The purpose of the dashboard is to give users a comprehensive view of their security posture by combining information from different sources such as scan results, monitor alerts, audit reports, findings from red team engagements, and any violations of firewall policies. This culminates in a singular security report that can quickly inform users of their overall security status.


[object Object]
[object Object]


[object Object]

[object Object] Upon receiving these commands, the dashboard will read data from various VEXT Shield components without altering th... | The [object Object] skill is designed to automate the extraction, analysis, and reporting of Google Analytics 4 (GA4) data to optimize business growth through actionable insights. This skill streamlines the various processes involved in handling vast amounts of analytics data that modern businesses accumulate but often struggle to analyze efficiently. The main functions of the skill include automated data extraction from GA4 using the Google Analytics Data API, statistical anomaly detection to identify unusual traffic trends, and the generation of professional-grade reports that suggest data-driven growth strategies. The skill is particularly useful for marketing teams, SaaS founders, e-commerce managers, and growth analysts.\n\n### Workflow Steps and Control Flow\n1. [object Object]: Connects to GA4 to pull metrics such as user counts, page views, traffic sources, and conversions. It facilitates queries like fetching conversion events segmented by traff... |

Loss: TripletLoss with these parameters:

json
1{ 2 "distance_metric": "TripletDistanceMetric.EUCLIDEAN", 3 "triplet_margin": 0.2 4}

Training Hyperparameters

Non-Default Hyperparameters

eval_strategy: epoch
per_device_train_batch_size: 128
learning_rate: 2e-05
warmup_steps: 200
seed: 13
bf16: True
dataloader_num_workers: 4
gradient_checkpointing: True

All Hyperparameters

Click to expand

overwrite_output_dir: False
do_predict: False
eval_strategy: epoch
prediction_loss_only: True
per_device_train_batch_size: 128
per_device_eval_batch_size: 8
per_gpu_train_batch_size: None
per_gpu_eval_batch_size: None
gradient_accumulation_steps: 1
eval_accumulation_steps: None
torch_empty_cache_steps: None
learning_rate: 2e-05
weight_decay: 0.0
adam_beta1: 0.9
adam_beta2: 0.999
adam_epsilon: 1e-08
max_grad_norm: 1.0
num_train_epochs: 3
max_steps: -1
lr_scheduler_type: linear
lr_scheduler_kwargs: None
warmup_ratio: 0.0
warmup_steps: 200
log_level: passive
log_level_replica: warning
log_on_each_node: True
logging_nan_inf_filter: True
save_safetensors: True
save_on_each_node: False
save_only_model: False
restore_callback_states_from_checkpoint: False
no_cuda: False
use_cpu: False
use_mps_device: False
seed: 13
data_seed: None
jit_mode_eval: False
bf16: True
fp16: False
fp16_opt_level: O1
half_precision_backend: auto
bf16_full_eval: False
fp16_full_eval: False
tf32: None
local_rank: 0
ddp_backend: None
tpu_num_cores: None
tpu_metrics_debug: False
debug: []
dataloader_drop_last: True
dataloader_num_workers: 4
dataloader_prefetch_factor: None
past_index: -1
disable_tqdm: False
remove_unused_columns: True
label_names: None
load_best_model_at_end: False
ignore_data_skip: False
fsdp: []
fsdp_min_num_params: 0
fsdp_config: {'min_num_params': 0, 'xla': False, 'xla_fsdp_v2': False, 'xla_fsdp_grad_ckpt': False}
fsdp_transformer_layer_cls_to_wrap: None
accelerator_config: {'split_batches': False, 'dispatch_batches': None, 'even_batches': True, 'use_seedable_sampler': True, 'non_blocking': False, 'gradient_accumulation_kwargs': None}
parallelism_config: None
deepspeed: None
label_smoothing_factor: 0.0
optim: adamw_torch
optim_args: None
adafactor: False
group_by_length: False
length_column_name: length
project: huggingface
trackio_space_id: trackio
ddp_find_unused_parameters: None
ddp_bucket_cap_mb: None
ddp_broadcast_buffers: False
dataloader_pin_memory: True
dataloader_persistent_workers: False
skip_memory_metrics: True
use_legacy_prediction_loop: False
push_to_hub: False
resume_from_checkpoint: None
hub_model_id: None
hub_strategy: every_save
hub_private_repo: None
hub_always_push: False
hub_revision: None
gradient_checkpointing: True
gradient_checkpointing_kwargs: None
include_inputs_for_metrics: False
include_for_metrics: []
eval_do_concat_batches: True
fp16_backend: auto
push_to_hub_model_id: None
push_to_hub_organization: None
mp_parameters:
auto_find_batch_size: False
full_determinism: False
torchdynamo: None
ray_scope: last
ddp_timeout: 1800
torch_compile: False
torch_compile_backend: None
torch_compile_mode: None
include_tokens_per_second: False
include_num_input_tokens_seen: no
neftune_noise_alpha: None
optim_target_modules: None
batch_eval_metrics: False
eval_on_start: False
use_liger_kernel: False
liger_kernel_config: None
eval_use_gather_object: False
average_tokens_across_devices: True
prompts: None
batch_sampler: batch_sampler
multi_dataset_batch_sampler: proportional
router_mapping: {}
learning_rate_mapping: {}

Training Logs

Epoch	Step
1.0	470

Training Time

Training: 2.2 hours
Evaluation: 1.4 minutes
Total: 2.2 hours

Framework Versions

Python: 3.13.3
Sentence Transformers: 5.4.0
Transformers: 4.57.6
PyTorch: 2.6.0+cu124
Accelerate: 1.13.0
Datasets: 4.8.4
Tokenizers: 0.22.2

Citation

BibTeX

Sentence Transformers

bibtex

@inproceedings{reimers-2019-sentence-bert,
    title = "Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks",
    author = "Reimers, Nils and Gurevych, Iryna",
    booktitle = "Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing",
    month = "11",
    year = "2019",
    publisher = "Association for Computational Linguistics",
    url = "https://arxiv.org/abs/1908.10084",
}

TripletLoss