Parse Stack Next MCPサーバー

Parse Stack Next

A full-featured Ruby client SDK for Parse Server. parse-stack-next is a Ruby client SDK, REST client, and Active Model ORM for Parse Server, combining a low-level API client, a query engine, an object-relational mapper (ORM), and a Cloud Code Webhooks rack application in a single gem.

What's new in 5.8

• 5.8.0: MCP deployments can expose less than their users can read. Parse::Agent.new(fields: { Customer => %i[display_name timezone] }) narrows a class's agent_fields for one agent, so a user-facing assistant and an analytics endpoint in one process expose different subsets of the same model. It applies to queries, includes, aggregation, search, schema output, exports, and semantic_search text, and query_class/count_objects/export_data now refuse filtering or sorting on a hidden field. See CHANGELOG.md
• 5.8.0: Supported deployment patterns. MCPRackApp.user_scoped serves signed-in application users (no master-key fallback, server-pinned identity and tenant), and MCPRackApp.master_analytics serves a shared read-only analytics endpoint that requires an operator principal_resolver. Cancellations and approval replies are now bound to the session's owner, revocation intervals are documented, and orphaned subscriptions are reaped. See CHANGELOG.md
• 5.8.0: Retrieval profiles for semantic_search. Profiles you register on the server (for example fast, balanced, precise; none ship by default) compose hybrid search and reranking with budgets, spend accounting, and observable fallback; each call emits a sanitized parse.retrieval.search event, and Parse::Retrieval::Benchmark measures profiles on labeled cases. See CHANGELOG.md
• 5.8.0: Vector index definitions from the model, with optional quantization. Parse::VectorSearch::IndexDefinition generates the Atlas definition from your declarations (filters and tenant field included) with preview and diff, and quantization: :scalar/:binary on a :vector property shrinks index memory without changing stored data. Contextualized embedding batches now adapt to provider size limits. See CHANGELOG.md
• 5.8.0: Two silent mismatches fixed; check whether you need to act. Queries now send a property's declared field: name exactly as declared (property :account_id, :string, field: :account_id queries account_id, no longer accountId), so queries that matched nothing against underscore or mixed-case columns now return rows. Vector search, index auto-discovery, and drift checks now use the stored column of a multi-word :vector property: an Atlas vector index whose path is the Ruby name (body_embedding) must be recreated on the stored column (bodyEmbedding). Drift detection reports the mismatch. See CHANGELOG.md

See CHANGELOG.md for the full 5.8 entry.

What's new in 5.7

• 5.7.6: semantic_search respects agent_fields for chunk content. A class that embedded a field hidden by its agent_fields allowlist returned that field's text as chunk content. Chunk text now comes only from embedded fields the agent may read; a hidden text source is refused with :field_denied before the search runs. See CHANGELOG.md
• 5.7.5: MongoDB 9.0 support. The test stack runs MongoDB 9 by default (MONGO_VERSION=8 selects the previous major), and use the mongo driver 2.26 or newer for 9.0's overload handling. MongoDB 9.0 changes how null comparisons treat dotted paths through arrays; see the behavior notes in CHANGELOG.md
• 5.7.5: voyage-code-4 and contextualized chunk embeddings. The Voyage provider accepts voyage-code-4, voyage-context-4, and voyage-context-3. Voyage#embed_chunks embeds whole chunked documents so each chunk's vector carries its document's context. See CHANGELOG.md
• 5.7.5: Voyage reranker and MCP 2025-11-25. Parse::Retrieval::Reranker::Voyage adds rerank-3 and rerank-3-lite reranking, including through the Atlas endpoint. The MCP server negotiates protocol 2025-11-25 and adds completion/complete (class and field names scoped to the agent) and logging/setLevel. Mongo-direct reads re-run queries MongoDB 9.0 kills mid-flight. See CHANGELOG.md
• 5.7.0: Reserved, app-scoped cache keyspace. Parse::Cache::Keyspace lays out response, identity, and role-cache keys on a shared backend (parse-stack:v1:<app_scope>[:<namespace>]:<family>[:T:<tenant>]:<rest>) and owns the glob patterns that clear them again, so key generation and eviction can no longer drift apart. app_scope is a digest of the application id and server URL, so two apps sharing one Redis no longer collide. Enable with cache_keyspace: true on Parse.setup; left unset, behavior is unchanged. See CHANGELOG.md
• 5.7.0: clear_cache! stops falling back to FLUSHDB. With cache_keyspace: true, Parse::Client#clear_cache! performs a scoped SCAN inside the client's own keys instead of flushing the whole database, which previously could destroy co-tenant data and drop first_or_create! create-locks on a shared Redis. flush_db! remains the explicit opt-in for a full flush. See CHANGELOG.md
• 5.7.0: Response-cache auth separation enforced by construction. Parse::Cache::Keyspace#cache_key now requires an auth: discriminator for the response-cache family and refuses to build a key without one, so a master-key body and a session-token body can no longer land under the same key by accident. A non-GET write now invalidates every auth variant of a resource in one scoped pattern instead of only the variants the process has already seen. See CHANGELOG.md
• 5.7.0: Shared identity and role planes. Parse::Cache::ScopedView#identity and #roles, reached through client.sdk_cache, return Parse::Cache::SubCache planes for the client's authorization context, so every worker resolves a session token or role closure against one shared backend instead of its own in-process cache. Each plane invalidates by per-subject generation counter and plane-wide epoch rather than needing to enumerate entries it cannot name. See CHANGELOG.md
• 5.7.0: Authorization becomes a client-owned module, not an Atlas Search internal. Parse::Authorization now owns session-token resolution and role-closure expansion. client.authorization returns a Parse::Authorization::Context, one per Parse::Client, so two clients addressing two Parse applications no longer share one identity cache and one role cache, and a mongo-direct query with no $search anywhere in it no longer resolves identity through the Atlas Search namespace. Parse::AtlasSearch.session_cache=, .role_cache=, and Parse::AtlasSearch::Session remain as deprecated aliases for the default client's context, slated for removal in 6.0. See CHANGELOG.md
• 5.7.0: Mongo-direct reads stay bound to the authorizing client. Parse::MongoDB.verify_client! rejects a direct read when its authorization client belongs to a different Parse application than the process-global MongoDB connection. Direct-query entry points accept client: and carry it through authorization and collection binding. See CHANGELOG.md
• 5.7.0: Effective access decisions for users and roles. Parse::Access.check, Parse::Access::Decision, and the can_read? / can_write? / can_delete? helpers combine object ACLs with class-level permissions and inherited roles. Unknown evidence fails closed, and the eventual Parse Server request remains authoritative. See CHANGELOG.md
• 5.7.0: Cache invalidation no longer depends on application discipline. Parse::Cache::Invalidation registers webhook triggers on _Role, _User, and _Session (after_save/after_delete/after_logout) that keep the identity and role planes honest for writes from any client, not only the app's own logout and role-mutation code paths. Installs alongside the keyspace; disable with cache_invalidation_hooks: false. See CHANGELOG.md
• 5.7.0: Optional read of Parse Server's own role cache. Parse::Cache::UpstreamRoles can read the <appId>:role:<userId> closure Parse Server already wrote for itself. Role resolution does not consume it: the SDK still computes its own closure, and the only built-in integration is compare_upstream_roles, which emits a parse.cache.role_compare event so the two can be reconciled before anything depends on the upstream value. Call roles_for directly to use it. Strictly read-only, degrades to a miss on any anomaly, and Parse::Cache::Redis#verify_upstream_isolation! reports whether the two Redis endpoints share one database. See CHANGELOG.md

See CHANGELOG.md for the full 5.7 entry, including behavior notes and a complete setup example.

What's new in 5.6

• 5.6.0: Voyage embeddings reach the Atlas endpoint, video, and streamed media. The Voyage provider now targets MongoDB's Atlas Embedding and Reranking API as well as Voyage's own; an Atlas-prefixed key routes automatically, or pass endpoint: :atlas / :voyage explicitly. Adds voyage-3.5, voyage-3.5-lite, voyage-code-2, and voyage-multimodal-3.5, plus embed_video. Parse::Embeddings::MediaFile streams local image and video uploads into the request body in fixed-size chunks instead of buffering them, bounding peak memory regardless of file size. See CHANGELOG.md
• 5.6.0 (Breaking): Voyage's default model moves to voyage-3.5. voyage-3 is retired from the Atlas endpoint, so the old default failed at construction for an Atlas key with no model named. Code relying on the previous default should pin model: "voyage-3" to keep existing embeddings valid, or re-embed against voyage-3.5. See CHANGELOG.md
• 5.6.0: Vector search no longer underfills. $vectorSearch applied its limit before the SDK's ACL match, protectedFields redaction, and pointer filtering, so a scoped caller who could read 2 of the top 10 documents got 2 results even when hundreds of readable matches existed further down the ranking. The search now requests a wider internal candidate window, applies every enforcement layer, and only then trims to the requested count; a candidate_limit: option tunes the window, and a parse.vector_search.search notification reports attrition. Hybrid search's own candidate-window and fusion-depth bugs are fixed the same way. See CHANGELOG.md
• 5.6.0: :vector properties are checked against the provider actually registered. A property's declared model: was recorded but never enforced, so swapping the registered provider's model could silently mix incomparable vectors into one index with no error. Parse::Embeddings::BindingAudit now checks model: and dimensions: before any request, on both the managed-write and query-embedding paths, and fails closed if the provider cannot report either. Parse::Embeddings::BindingAudit.audit_all! checks every declared binding at once for a boot-time or CI gate. See CHANGELOG.md
• 5.6.0: Corrected the model dimension table. The entire Voyage v4 family defaults to 1024; voyage-4-large's 2048 and voyage-4-lite's 512 were recorded as native widths when they are Matryoshka options reached only by requesting them, which made both models raise Parse::Embeddings::InvalidResponseError on every call. Any width on a model's Matryoshka ladder is now accepted. See CHANGELOG.md

See CHANGELOG.md for the full 5.6 entry.

What's new in 5.5

• 5.5.0 — Multimodal bytes-fetch with magic-byte MIME verification — embed_image ..., source: :bytes has the SDK download an image itself through the Parse::File.safe_open_url SSRF primitive, verify the content by magic-byte sniff (the Content-Type header is never consulted — a .jpg URL serving HTML is refused), cross-check the URL extension, enforce a Parse::Embeddings.allowed_image_types allowlist, strip EXIF/XMP metadata by default (JPEG APP1, PNG eXIf, WebP EXIF/XMP chunks; opt out with exif_strip: false), and forward the verified bytes to Voyage/Cohere as a base64 data URI. No provider-side URL fetch occurs, so the trust_provider_url_fetch sentinel is not required — the host allowlist still applies. See CHANGELOG.md
• 5.5.0 — Embedding-model migration tooling — Class.reembed!(only_stale: true) bulk re-embeds rows through the current provider/model (resumable; skips rows already current), driven by the new auto-declared <into>_meta provenance sibling ({provider, model, dimensions, modality, embedded_at}, stamped on every recompute). Parse::Embeddings::BatchEmbedder adds batch-level requests-per-minute pacing and exponential backoff for bulk jobs; Parse::Embeddings::Cache.enable! adds an opt-in query-embed cache keyed by (provider, model, input_type, input-hash) so repeated identical queries skip the provider round-trip. See CHANGELOG.md
• 5.5.0 — Vector index drift detection — on first auto-discovered use of an Atlas vectorSearch index, the SDK verifies the deployed index's numDimensions/similarity against the :vector property declaration and confirms a registered agent_tenant_scope field is covered as a type: "filter" path. Policy via Parse::VectorSearch.index_drift_policy (:warn default / :raise / :ignore). Parse::Schema::SearchIndexMigrator now auto-includes the tenant-scope field in vectorSearch declarations, so newly created indexes support tenant-scoped pre-filtering out of the box. See CHANGELOG.md
• 5.5.0 — Retrieval spend-cap and filter hardening — the per-tenant embedding spend cap now covers every query-embed path (find_similar(text:), hybrid_search(text:), Parse::Retrieval.retrieve), not just the semantic_search agent tool; tenant identity resolves through the ambient Parse.with_cache_tenant scope. Caller-supplied retrieval filters now translate Parse pointer values to storage form ({ owner: user } → { "_p_owner" => "_User$id" }), so pointer filters match rows instead of silently matching nothing. See CHANGELOG.md

What's new in 5.4

• 5.4.0 — Hybrid search + reranking for RAG — Class.hybrid_search(text:, lexical:, vector:, k:, fusion:) fuses a lexical Atlas Search branch with a $vectorSearch branch using reciprocal-rank fusion (RRF): lexical search nails exact tokens (codes, proper nouns), vector search nails paraphrase, and fusing the two beats either alone. Each branch enforces ACL/CLP independently before fusion (no separate hydration fetch to secure); results carry #hybrid_score / #hybrid_ranks. Parse::VectorSearch::Hybrid.rank_fusion_supported? detects Atlas 8.0+ native $rankFusion by a cached behavioural probe (native execution is opt-in; client-side RRF is the always-enforced default). Parse::Retrieval::Reranker adds cross-encoder reranking (Reranker::Cohere over /v2/rerank, plus a deterministic Reranker::Fixture), wired into Parse::Retrieval.retrieve(hybrid:, rerank:). Parse::Embeddings::SpendCap adds an opt-in per-tenant embedding token cap (hard-refuse) at the semantic_search agent-tool boundary. See CHANGELOG.md and docs/atlas_vector_search_guide.md
• 5.4.0 — Vector backfill, visibility, and webhook redaction — Class.embed_pending! backfills embeddings for records whose managed :vector field is null (objectId-cursor pagination); Parse::Object#compute_embedding! forces an in-place recompute without a save; vector_visibility :owner_only | :public controls whether a class's vectors appear in as_json by default; and webhook trigger payloads now strip declared :vector columns by default (a :public class keeps them). See CHANGELOG.md
• 5.4.0 — TOTP multi-factor auth works end to end — the Parse::User MFA lifecycle is now fully functional and exercised against a real MFA-enabled Parse Server. setup_mfa!(secret:, token:) enrolls TOTP and returns recovery codes; Parse::User.login_with_mfa(user, pass, code) completes a second-factor login; mfa_enabled? / mfa_status report enrollment after an ordinary fetch — the SDK strips the raw TOTP secret and recovery codes that Parse Server returns in authData but preserves a leak-safe {status: "enabled"} projection so the status reads correctly without exposing the secret; disable_mfa!(current_token:) turns MFA off after re-validating the current code (a wrong code raises Parse::MFA::VerificationError), and disable_mfa_master_key!(authorized_by:) is the operator override. Each MFA write also no longer raises an internal argument error before reaching the server. Interactively, rake client:console now prompts for a TOTP / recovery code (or reads PARSE_LOGIN_MFA) when logging into an enrolled account. See CHANGELOG.md
• 5.4.0 — Request email-address verification — Parse::User.request_email_verification(email) and the instance Parse::User#request_email_verification ask Parse Server to (re)send the verification email for a registered, not-yet-verified user, mirroring request_password_reset (per-email rate limiting, Boolean return). Requires a server email adapter with verifyUserEmails enabled. See CHANGELOG.md
• 5.4.0 — Audience hash queries persist correctly — Parse::Audience#query is now stored as a JSON string on the wire to match Parse Server's _Audience.query column type, so saving an audience with a Hash query no longer fails the server schema check. The public API is unchanged — assign a Hash, read a Hash back. See CHANGELOG.md
• 5.4.0 — Faster AtlasSearch role-cache expiry — Parse::AtlasSearch role_cache_ttl now defaults to 30 seconds (was 120) so a role grant or revoke is reflected in $search ACL decisions sooner, at the cost of slightly more frequent role lookups. See CHANGELOG.md

What's new in 5.3

• 5.3.0 — Run webhook handlers (and clients) as the calling user — Parse Server embeds the caller's live session token in every trigger webhook fired by a logged-in user. A handler can now opt in to acting on the server as that user — full ACL/CLP/protectedFields enforcement, no master key. payload.session_token exposes the captured token (nil for master-key requests; still scrubbed from payload.user/payload.object/as_json/logs); payload.user_agent returns a client-mode Parse::Agent, and payload.user_client a non-master Parse::Client with the token bound so even raw REST calls authorize as the user. The same user-scoped client is available client-side via Parse::User#session_client and the Parse::Client#become(token) primitive, with Parse::Client#with_session { … } for block scoping. Backed by a new Parse::Client.new(session_token:) option. See Acting as the calling user
• 5.3.0 — Pluralized class-name aliases — referencing the plural form of a model constant now resolves to that class, so Posts.where(:author.eq => user).count works for a class Post. The alias is created lazily on first reference and is the same class object, so every class method (query/where, count, find, all, scopes) works through it and Posts.parse_class still returns "Post". Because it is the same class it adds no Parse::Object.descendants entry and never registers a separate Parse schema class. Classes whose name already ends in s are skipped by the automatic path; non-Parse plurals and typos fall through to a normal NameError. On by default — opt out with Parse.pluralized_aliases = false (or PARSE_PLURALIZED_ALIASES=false). For a custom plural, an s-ending class, or a namespaced model, call pluralized_alias! in the class body. See Pluralized class-name aliases
• 5.3.0 — afterSave create reports changed fields; force_ssl-consistent file equality — a trigger handler that keys off dirty tracking now sees every field on an afterSave create, symmetric with afterSave updates: the built object marks each populated data property changed (from nil) while createdAt/updatedAt/ACL/objectId stay clean and object readability, new?, and existed? are unchanged — so a handler that builds a payload from *_changed? / changes works uniformly across create and update. Separately, Parse::File#== now compares both files through the canonical url reader, so two files at the same location compare equal regardless of Parse::File.force_ssl (and a == b matches b == a), and a re-signed URL for the same object no longer reads as a change. See Cloud Code Triggers