{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"pypi_pypi-together","slug":"pypi-together","name":"together","type":"api","url":"https://pypi.org/project/together/","page_url":"https://unfragile.ai/pypi-together","categories":["llm-apis"],"tags":[],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"pypi_pypi-together__cap_0","uri":"capability://tool.use.integration.dual.mode.http.client.with.automatic.retry.logic.and.configurable.backends","name":"dual-mode http client with automatic retry logic and configurable backends","description":"Provides both synchronous (Together) and asynchronous (AsyncTogether) HTTP clients built on httpx with configurable exponential backoff retry strategies for transient failures. The architecture uses a base client pattern (_BaseClient) that abstracts HTTP operations, allowing runtime selection between httpx (default) and aiohttp backends for async workloads. Automatic retry logic with configurable max retries and backoff multipliers handles network transience without developer intervention.","intents":["I need a Python client that handles both sync and async API calls to Together without managing connection pooling myself","I want automatic retry logic with exponential backoff for flaky network conditions","I need to switch HTTP backends (httpx vs aiohttp) based on my concurrency requirements"],"best_for":["Python developers building LLM applications with sync/async flexibility","Teams requiring high-concurrency async workloads with aiohttp backend","Developers who want production-grade retry handling out-of-the-box"],"limitations":["Retry logic only handles transient HTTP errors (5xx, timeouts); application-level errors require custom handling","aiohttp backend requires explicit installation as optional dependency; default httpx may not match all concurrency patterns","No built-in circuit breaker or rate-limiting — relies on Together API rate limit headers"],"requires":["Python 3.9 or higher","httpx library (installed by default)","aiohttp library (optional, for async backend alternative)","TOGETHER_API_KEY environment variable or explicit api_key parameter"],"input_types":["HTTP request parameters (method, URL, headers, body)","Configuration objects (timeout, max_retries, base_url)"],"output_types":["HTTP response objects (status, headers, body)","Parsed JSON responses","Streaming response iterators (for SSE)"],"categories":["tool-use-integration","http-client"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-together__cap_1","uri":"capability://text.generation.language.server.sent.events.sse.streaming.with.token.level.granularity","name":"server-sent events (sse) streaming with token-level granularity","description":"Implements real-time token streaming via Server-Sent Events (SSE) for both synchronous and asynchronous clients by setting stream=True on API calls. The streaming layer (_streaming.py) parses SSE-formatted responses and yields individual tokens or completion chunks as they arrive from the server, enabling low-latency token consumption for chat and text generation endpoints. Supports both line-by-line iteration (sync) and async iteration patterns.","intents":["I need to display LLM tokens in real-time as they're generated, not wait for the full response","I want to build a streaming chat interface that shows tokens arriving incrementally","I need to consume streaming responses in both sync and async contexts without managing SSE parsing"],"best_for":["Frontend developers building real-time chat UIs with streaming token display","Backend engineers implementing streaming APIs that proxy Together's responses","LLM application developers who need sub-second token latency"],"limitations":["SSE streaming only works with endpoints that support stream=True parameter; not all Together endpoints support streaming","Streaming responses cannot be retried mid-stream — connection loss requires full request restart","Token-level granularity depends on server-side chunking; no client-side token re-aggregation"],"requires":["Python 3.9+","httpx or aiohttp with SSE support","API endpoint that supports stream=True (chat.completions, text.completions, etc.)"],"input_types":["API request with stream=True parameter","Chat messages or prompt text"],"output_types":["Iterator[CompletionChunk] (sync)","AsyncIterator[CompletionChunk] (async)","Individual token strings"],"categories":["text-generation-language","streaming"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-together__cap_10","uri":"capability://automation.workflow.batch.processing.for.asynchronous.bulk.inference","name":"batch processing for asynchronous bulk inference","description":"Implements the batch resource for processing large numbers of requests asynchronously in a single batch job. Developers submit a JSONL file containing multiple API requests, and the batch API processes them in parallel, returning results in a JSONL output file. Batch processing is significantly cheaper than real-time API calls but introduces latency (typically hours). The API provides job status monitoring and result retrieval.","intents":["I need to process thousands of inference requests cost-effectively without real-time latency requirements","I want to submit a batch of prompts and retrieve results later without managing individual API calls","I need to reduce API costs for non-time-sensitive workloads like data labeling or content generation"],"best_for":["Data scientists processing large datasets for analysis or labeling","Teams running nightly batch jobs for content generation or data enrichment","Builders implementing cost-optimized inference pipelines"],"limitations":["Batch processing introduces hours of latency; not suitable for real-time applications","JSONL format is strict; malformed requests are silently skipped or cause batch failure","No streaming results; must wait for entire batch to complete before retrieving output","Batch size limits apply (typically 10k-100k requests per batch)"],"requires":["Python 3.9+","Together API key","JSONL file with properly formatted API requests","Patience for batch processing (typically 1-24 hours)"],"input_types":["JSONL file with API requests (chat.completions, completions, etc.)","Batch metadata (description, optional)"],"output_types":["Batch object with batch_id and status","JSONL output file with results (one result per input request)"],"categories":["automation-workflow","batch-processing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-together__cap_11","uri":"capability://automation.workflow.file.management.with.upload.download.and.validation","name":"file management with upload, download, and validation","description":"Implements the files resource for managing data files used in fine-tuning, batch processing, and other workflows. The API provides file.upload (with format validation), file.retrieve (download), file.list (enumerate), and file.delete operations. Files are stored on Together's servers and referenced by file_id in downstream operations. The API validates file format (JSONL for training data) and provides storage quotas.","intents":["I need to upload training data for fine-tuning without managing file storage myself","I want to retrieve previously uploaded files for inspection or reuse","I need to validate file format before submitting to fine-tuning or batch jobs"],"best_for":["ML engineers managing training datasets","Teams implementing data pipelines with Together","Developers building applications that accept user-uploaded data for fine-tuning"],"limitations":["File storage is temporary; files may be deleted after a retention period (typically 30 days)","File size limits apply (typically 100MB per file); large datasets require chunking","No built-in file versioning or metadata management; developers must track file history externally"],"requires":["Python 3.9+","Together API key","File to upload (JSONL, CSV, or other supported format)"],"input_types":["File object or file path","File purpose ('fine-tune', 'batch', etc.)"],"output_types":["File object with file_id, filename, and size","File content (bytes) on download"],"categories":["automation-workflow","file-management"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-together__cap_12","uri":"capability://tool.use.integration.model.listing.and.metadata.retrieval","name":"model listing and metadata retrieval","description":"Implements the models resource for discovering available models and retrieving their metadata (context window, pricing, capabilities, etc.). The API provides models.list() to enumerate all available models and models.retrieve(model_id) to get detailed information about a specific model. Model metadata includes supported features (chat, completions, embeddings, etc.), pricing, and availability status.","intents":["I need to discover which models are available on Together for my use case","I want to compare model capabilities (context window, speed, cost) to choose the best one","I need to programmatically check if a model is available before using it"],"best_for":["Developers building model-agnostic applications that support multiple models","Teams evaluating different models for cost/performance tradeoffs","Builders implementing model selection logic based on capabilities"],"limitations":["Model metadata is static and may not reflect real-time availability","Pricing information is approximate; actual costs depend on usage patterns","No built-in model recommendation engine; developers must implement selection logic"],"requires":["Python 3.9+","Together API key (optional for listing public models)"],"input_types":["Model ID (string, optional for retrieve)"],"output_types":["List[Model] with metadata (name, context_window, pricing, capabilities)","Model object with detailed information"],"categories":["tool-use-integration","model-discovery"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-together__cap_13","uri":"capability://automation.workflow.cli.tools.for.file.model.fine.tuning.and.cluster.management","name":"cli tools for file, model, fine-tuning, and cluster management","description":"Provides command-line interface (CLI) tools for managing files, models, fine-tuning jobs, and clusters without writing Python code. The CLI mirrors the SDK API surface, exposing commands like 'together files upload', 'together fine-tuning create', 'together models list', etc. CLI tools are useful for scripting, automation, and interactive exploration of the Together API.","intents":["I want to upload training files and manage fine-tuning jobs from the command line","I need to script Together API operations in shell scripts or CI/CD pipelines","I want to explore the API interactively without writing Python code"],"best_for":["DevOps engineers automating ML workflows in CI/CD pipelines","Data scientists exploring the API from the command line","Teams implementing infrastructure-as-code for model training"],"limitations":["CLI tools are less flexible than Python SDK; complex workflows require shell scripting","Error messages may be less detailed than Python exceptions","No built-in progress bars or interactive prompts; output is text-based"],"requires":["Python 3.9+","together package installed (pip install together)","TOGETHER_API_KEY environment variable set"],"input_types":["Command-line arguments and flags","File paths (for upload operations)"],"output_types":["Text output (JSON, formatted tables, etc.)","Exit codes indicating success/failure"],"categories":["automation-workflow","cli"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-together__cap_14","uri":"capability://safety.moderation.error.handling.with.typed.exceptions.and.retry.guidance","name":"error handling with typed exceptions and retry guidance","description":"Implements a comprehensive error handling system with typed exception classes (APIError, AuthenticationError, RateLimitError, etc.) that provide context about failures. The SDK automatically retries transient errors (5xx, timeouts) with exponential backoff, but raises typed exceptions for application-level errors (4xx, auth failures). Error objects include request_id for debugging and suggestions for recovery.","intents":["I need to distinguish between transient errors (retry) and permanent errors (fail fast)","I want to implement custom error handling logic based on error type","I need to debug API failures using request IDs and error context"],"best_for":["Developers building production applications with robust error handling","Teams implementing custom retry logic or circuit breakers","Builders debugging API integration issues"],"limitations":["Automatic retries only handle transient HTTP errors; application-level errors require custom handling","Error messages may not always include actionable recovery suggestions","Request IDs are only available for Together-generated errors; network errors may lack context"],"requires":["Python 3.9+","Exception handling (try/except) in application code"],"input_types":["HTTP responses with error status codes"],"output_types":["Typed exception objects (APIError, AuthenticationError, RateLimitError, etc.)","Error context (status_code, request_id, message)"],"categories":["safety-moderation","error-handling"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-together__cap_15","uri":"capability://tool.use.integration.async.await.support.with.asynctogether.client.and.event.loop.integration","name":"async/await support with asynctogether client and event loop integration","description":"Provides a fully asynchronous client (AsyncTogether) that mirrors the synchronous Together client but uses async/await syntax and integrates with Python's asyncio event loop. All API resources are available on the async client with identical signatures. The async client uses aiohttp (optional) or httpx for HTTP operations, enabling high-concurrency workloads without blocking threads.","intents":["I need to make concurrent API calls without blocking threads or managing thread pools","I want to integrate Together API into async web frameworks (FastAPI, aiohttp, etc.)","I need to process streaming responses asynchronously in real-time"],"best_for":["Developers building async web applications (FastAPI, Starlette, etc.)","Teams implementing high-concurrency inference services","Builders creating async agents or orchestration systems"],"limitations":["Async client requires Python 3.9+ and asyncio event loop; not suitable for synchronous-only applications","Mixing sync and async code requires careful event loop management; can cause deadlocks if misused","aiohttp backend requires explicit installation; default httpx may not match all async patterns"],"requires":["Python 3.9+","asyncio event loop (built into Python)","aiohttp library (optional, for improved async performance)"],"input_types":["Same as synchronous client (API parameters, messages, etc.)"],"output_types":["Coroutines that return typed response objects","AsyncIterator for streaming responses"],"categories":["tool-use-integration","async"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-together__cap_2","uri":"capability://tool.use.integration.type.safe.api.resource.organization.with.pydantic.models.and.typeddict.parameters","name":"type-safe api resource organization with pydantic models and typeddict parameters","description":"Organizes 15+ API resources (chat, completions, images, audio, embeddings, fine-tuning, etc.) as typed attributes on the client using Pydantic models for response validation and TypedDict for request parameters. The type system enforces schema validation at runtime via Pydantic, catching malformed requests before they reach the API. Resources are lazily loaded via the _resources_proxy pattern to minimize import overhead.","intents":["I want IDE autocomplete and type hints for all Together API parameters and responses","I need runtime validation of API requests to catch schema errors before sending to the server","I want to explore available API resources and their parameters without reading documentation"],"best_for":["Python developers using type-aware IDEs (PyCharm, VS Code with Pylance)","Teams enforcing strict type checking with mypy or pyright","Developers building SDKs or libraries on top of Together that need type safety"],"limitations":["Pydantic validation adds ~5-10ms overhead per request for schema checking","TypedDict parameters are not enforced at runtime in Python < 3.13 (only via type checkers)","Custom model serialization required for non-standard types (e.g., file uploads); not all edge cases covered by auto-generated types"],"requires":["Python 3.9+","Pydantic v2.x (included in together package)","Type checker (mypy, pyright) for full type safety benefits"],"input_types":["TypedDict request parameters","Python dictionaries (converted to TypedDict at runtime)"],"output_types":["Pydantic BaseModel instances","Typed response objects (ChatCompletion, TextCompletion, Image, etc.)"],"categories":["tool-use-integration","type-safety"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-together__cap_3","uri":"capability://text.generation.language.chat.completions.with.multi.turn.conversation.management.and.system.prompts","name":"chat completions with multi-turn conversation management and system prompts","description":"Implements the chat.completions resource that accepts a list of Message objects (with role, content, and optional tool_calls) and returns a ChatCompletion response with choice objects containing the assistant's reply. Supports system prompts, multi-turn conversation history, and tool/function calling via the tools parameter. The API maintains conversation context across multiple calls, allowing developers to build stateful chat applications by managing message history client-side.","intents":["I need to build a multi-turn chatbot that maintains conversation context across API calls","I want to use system prompts to control the assistant's behavior and tone","I need to implement tool calling (function calling) so the LLM can invoke external functions"],"best_for":["Developers building conversational AI applications (chatbots, assistants)","Teams implementing agentic workflows with tool calling","Builders creating chat interfaces that need system-level control over model behavior"],"limitations":["Conversation history is not persisted server-side; developers must manage message history in application state","Tool calling responses require manual parsing and execution; no built-in tool execution framework","Max context window depends on model selection; no automatic context windowing or summarization"],"requires":["Python 3.9+","Together API key","Valid model name (e.g., 'meta-llama/Llama-3-70b-chat-hf')","Message list with at least one user message"],"input_types":["List[Message] with role ('user', 'assistant', 'system') and content","Optional tools parameter (list of tool schemas)","Optional system parameter (string)"],"output_types":["ChatCompletion object with choices[0].message containing role and content","Tool calls in message.tool_calls if tools were provided"],"categories":["text-generation-language","chat"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-together__cap_4","uri":"capability://text.generation.language.text.completions.with.prompt.based.generation.and.sampling.control","name":"text completions with prompt-based generation and sampling control","description":"Implements the completions resource for raw text generation (non-chat) that accepts a prompt string and returns a Completion response with generated text. Supports sampling parameters (temperature, top_p, top_k, repetition_penalty) for controlling output diversity and quality. Unlike chat completions, this endpoint does not maintain conversation context and is optimized for single-turn prompt-based generation tasks.","intents":["I need to generate text from a raw prompt without chat-style message formatting","I want to control output diversity using temperature, top_p, and top_k parameters","I need to use text completions for code generation, summarization, or other non-conversational tasks"],"best_for":["Developers building prompt-based generation pipelines (code gen, summarization, translation)","Teams fine-tuning sampling parameters for specific use cases","Builders migrating from OpenAI's legacy completions API"],"limitations":["No built-in prompt engineering or few-shot example management; developers must construct prompts manually","Sampling parameters (temperature, top_p) interact in complex ways; no guidance on optimal combinations","No automatic prompt validation; malformed prompts may produce low-quality outputs without error"],"requires":["Python 3.9+","Together API key","Valid model name (e.g., 'meta-llama/Llama-2-7b')","Prompt string"],"input_types":["prompt (string)","temperature (float, 0.0-2.0)","top_p (float, 0.0-1.0)","top_k (int)","repetition_penalty (float)"],"output_types":["Completion object with choices[0].text containing generated text","finish_reason indicating why generation stopped (length, stop_token, etc.)"],"categories":["text-generation-language","completions"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-together__cap_5","uri":"capability://image.visual.image.generation.with.model.selection.and.quality.parameters","name":"image generation with model selection and quality parameters","description":"Implements the images.generate resource that accepts a text prompt and returns generated images as URLs or base64-encoded data. Supports model selection (DALL-E 3, Stable Diffusion variants), quality parameters (steps, guidance_scale, seed), and output format control (url or base64). The API abstracts differences between underlying image generation models, providing a unified interface.","intents":["I need to generate images from text prompts using different models (DALL-E, Stable Diffusion)","I want to control image generation quality via guidance_scale and sampling steps","I need to retrieve generated images as URLs or base64 data for embedding in applications"],"best_for":["Developers building image generation features into applications","Teams experimenting with different image models without managing separate APIs","Builders creating content generation pipelines that combine text and image generation"],"limitations":["Image generation is slow (10-30 seconds per image); no streaming or progressive rendering","Model availability varies by Together plan; not all models available to all users","Generated images are temporary URLs; no built-in persistence or storage management"],"requires":["Python 3.9+","Together API key with image generation access","Valid image model name (e.g., 'DALL-E 3', 'Stable Diffusion 3')","Text prompt"],"input_types":["prompt (string)","model (string)","steps (int, 1-100)","guidance_scale (float, 0.0-20.0)","seed (int, optional)"],"output_types":["List[Image] with url or b64_json fields","Base64-encoded image data (if response_format='b64_json')"],"categories":["image-visual","generation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-together__cap_6","uri":"capability://image.visual.audio.processing.with.speech.to.text.and.text.to.speech","name":"audio processing with speech-to-text and text-to-speech","description":"Implements audio resources for transcription (speech-to-text via audio.transcriptions) and synthesis (text-to-speech via audio.speech). The transcription endpoint accepts audio files (WAV, MP3, M4A) and returns transcribed text with optional language detection. The speech endpoint accepts text and returns audio in specified format (MP3, WAV, etc.). Both endpoints support model selection and quality parameters.","intents":["I need to transcribe audio files to text for processing or storage","I want to generate spoken audio from text for voice applications or accessibility","I need to support multiple audio formats and quality levels in my application"],"best_for":["Developers building voice-enabled applications (voice assistants, transcription services)","Teams implementing accessibility features (text-to-speech for content)","Builders creating multimodal applications that combine text and audio"],"limitations":["Audio file size limits apply; very large files may require chunking or streaming","Transcription accuracy depends on audio quality and language; no built-in quality metrics","Text-to-speech output quality varies by model; no preview or quality control before generation"],"requires":["Python 3.9+","Together API key with audio access","Audio file (for transcription) or text (for synthesis)","Valid audio model name"],"input_types":["Audio file (WAV, MP3, M4A, FLAC, OGG)","Text string (for speech synthesis)","Language code (optional, for transcription)"],"output_types":["Transcription object with text field","Audio bytes in specified format (MP3, WAV, etc.)"],"categories":["image-visual","audio-processing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-together__cap_7","uri":"capability://data.processing.analysis.embeddings.generation.with.model.selection.and.batch.processing","name":"embeddings generation with model selection and batch processing","description":"Implements the embeddings.create resource that accepts text inputs and returns dense vector embeddings for semantic search, clustering, or similarity comparison. Supports batch processing of multiple texts in a single request, model selection (e.g., 'BAAI/bge-large-en-v1.5'), and configurable embedding dimensions. The API returns Embedding objects with vector data and input text reference.","intents":["I need to generate embeddings for text to enable semantic search or similarity matching","I want to batch-process multiple texts into embeddings efficiently","I need to select different embedding models for different use cases (multilingual, domain-specific)"],"best_for":["Developers building semantic search or RAG systems","Teams implementing similarity-based recommendation engines","Builders creating vector databases or embedding-based clustering"],"limitations":["Embeddings are model-specific; switching models requires re-embedding all data","No built-in vector storage or indexing; requires external vector database (Pinecone, Weaviate, etc.)","Batch size limits apply; very large batches may require chunking"],"requires":["Python 3.9+","Together API key","Valid embedding model name (e.g., 'BAAI/bge-large-en-v1.5')","Text input(s)"],"input_types":["input (string or List[string])","model (string)","encoding_format (optional, 'float' or 'base64')"],"output_types":["List[Embedding] with embedding (vector) and index fields","Vector data as float array or base64-encoded bytes"],"categories":["data-processing-analysis","embeddings"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-together__cap_8","uri":"capability://automation.workflow.fine.tuning.with.dataset.management.and.training.monitoring","name":"fine-tuning with dataset management and training monitoring","description":"Implements the fine_tuning resource for training custom models on user-provided datasets. The API manages the full fine-tuning lifecycle: dataset upload (via files.upload), job creation (fine_tuning.jobs.create), status monitoring (fine_tuning.jobs.retrieve), and model deployment. Fine-tuning jobs are asynchronous and can be polled for completion status. The API validates dataset format and provides training metrics.","intents":["I need to fine-tune a model on my own data to improve performance on domain-specific tasks","I want to monitor fine-tuning job progress and retrieve trained model checkpoints","I need to upload training datasets and manage their lifecycle through the fine-tuning process"],"best_for":["ML engineers building custom models for specific domains","Teams with proprietary data who want to improve model performance","Developers implementing MLOps pipelines with automated fine-tuning"],"limitations":["Fine-tuning is asynchronous and can take hours to days; no real-time progress streaming","Dataset format requirements are strict (JSONL with specific schema); malformed data causes silent failures","Fine-tuned models are stored on Together's servers; no option for local model export"],"requires":["Python 3.9+","Together API key with fine-tuning access","Training dataset in JSONL format (prompt-completion pairs)","Base model name (e.g., 'meta-llama/Llama-2-7b')"],"input_types":["JSONL file with training examples","Base model name","Training hyperparameters (learning_rate, num_epochs, etc.)"],"output_types":["FineTuningJob object with status, job_id, and model_id","Training metrics (loss, accuracy, etc.)","Fine-tuned model name for inference"],"categories":["automation-workflow","fine-tuning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-together__cap_9","uri":"capability://automation.workflow.dedicated.endpoints.for.custom.model.deployment.and.inference","name":"dedicated endpoints for custom model deployment and inference","description":"Implements the endpoints resource for deploying fine-tuned or custom models to dedicated inference endpoints with guaranteed availability and performance. The API manages endpoint lifecycle: creation (endpoints.create), status monitoring (endpoints.retrieve), and inference (endpoints.chat.completions). Dedicated endpoints provide lower latency and higher throughput than shared API endpoints, with optional auto-scaling.","intents":["I need to deploy a fine-tuned model to a dedicated endpoint for production inference","I want guaranteed availability and low-latency inference for my custom model","I need to scale inference capacity independently from the shared API"],"best_for":["Teams running production LLM services with SLA requirements","Developers deploying fine-tuned models that need consistent performance","Builders implementing multi-tenant systems with isolated model endpoints"],"limitations":["Dedicated endpoints incur additional costs; not suitable for low-volume or experimental use","Endpoint provisioning takes time (minutes to hours); not suitable for rapid iteration","Auto-scaling configuration is limited; no fine-grained control over scaling policies"],"requires":["Python 3.9+","Together API key with endpoint access","Fine-tuned model or custom model name","Sufficient API quota for dedicated endpoints"],"input_types":["model (fine-tuned model name)","name (endpoint name)","auto_scale (boolean, optional)"],"output_types":["Endpoint object with endpoint_id, status, and inference_url","Chat completion responses from dedicated endpoint"],"categories":["automation-workflow","deployment"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":27,"verified":false,"data_access_risk":"high","permissions":["Python 3.9 or higher","httpx library (installed by default)","aiohttp library (optional, for async backend alternative)","TOGETHER_API_KEY environment variable or explicit api_key parameter","Python 3.9+","httpx or aiohttp with SSE support","API endpoint that supports stream=True (chat.completions, text.completions, etc.)","Together API key","JSONL file with properly formatted API requests","Patience for batch processing (typically 1-24 hours)"],"failure_modes":["Retry logic only handles transient HTTP errors (5xx, timeouts); application-level errors require custom handling","aiohttp backend requires explicit installation as optional dependency; default httpx may not match all concurrency patterns","No built-in circuit breaker or rate-limiting — relies on Together API rate limit headers","SSE streaming only works with endpoints that support stream=True parameter; not all Together endpoints support streaming","Streaming responses cannot be retried mid-stream — connection loss requires full request restart","Token-level granularity depends on server-side chunking; no client-side token re-aggregation","Batch processing introduces hours of latency; not suitable for real-time applications","JSONL format is strict; malformed requests are silently skipped or cause batch failure","No streaming results; must wait for entire batch to complete before retrieving output","Batch size limits apply (typically 10k-100k requests per batch)","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.35,"ecosystem":0.39999999999999997,"match_graph":0.25,"freshness":0.52,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.1,"match_graph":0.28,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:25.061Z","last_scraped_at":"2026-05-03T15:20:10.823Z","last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=pypi-together","compare_url":"https://unfragile.ai/compare?artifact=pypi-together"}},"signature":"wqlWyOSba7euZ9bJtZRN+VmVsk3kc0WBAsSrlQsYU8gtG/tGRYXJQv1j0KpnR7TQ1CHJs1vBES4/rKrL3zCnAw==","signedAt":"2026-06-22T02:57:22.670Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/pypi-together","artifact":"https://unfragile.ai/pypi-together","verify":"https://unfragile.ai/api/v1/verify?slug=pypi-together","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}