AI 클라이언트가 Jev에게 yes/no, 선택형, 점수형 질문을 던지고 결정에 필요한 보정된 확률값을 받을 수 있게 합니다.
다른 이름 PerryLink/jevcore, jevcore-mcp
- 스타
- 105
- Tools
- —
- 다운로드, 30일
- —
- 최신 버전
- —
- 마지막 커밋
- 2026년 11월 9일
- 라이선스
- Apache-2.0
jevcore MCP란?
jevcore은(는) MCP server입니다. AI 클라이언트가 Jev에게 yes/no, 선택형, 점수형 질문을 던지고 결정에 필요한 보정된 확률값을 받을 수 있게 합니다.
프로젝트 README에서 생성된 요약
jevcore MCP server 정보
정밀한 의사결정이 필요한 AI agent를 구축하는 개발자는 jevcore를 사용하여 워크플로우에 보정된 확률값을 통합할 수 있습니다. 이 MCP server는 채팅 모델이 산문을 작성하는 방식 대신, yes/no, 선택지 또는 수치 점수와 같은 타입 지정 질문을 던질 수 있는 전용 인터페이스를 제공합니다. MCP 호환 host 또는 DeepSeek Harness와 함께 사용하도록 설계되었으며, 로컬 통합을 위해 stdio를 통해 작동합니다.
이 시스템은 기본적으로 합성 모크 프로바이더를 사용하는 오프라인 상태를 유지하여 개인정보 보호와 제어권을 우선시합니다. 실제 모델을 사용하려면 명시적으로 동의해야 하며, TYPESAFE_API_KEY 또는 OPENROUTER_API_KEY와 같은 환경 변수를 통해 인증 정보를 제공해야 합니다. 일반 질문을 위한 jev_ask, 후보군 평가를 위한 jev_rank, 증거를 바탕으로 주장을 검증하는 jev_check 등 세 가지 특정 도구를 제공합니다. 이를 통해 agent는 대화형 텍스트가 아닌 구조화되고 측정 가능한 데이터를 수신할 수 있습니다.
활용 사례
- 1여러 후보 평가agent가 특정 기준에 따라 잠재적 옵션 목록의 순위를 매겨 최적의 대안을 찾을 수 있습니다.
- 2사실 관계 검증개발자가 AI에게 특정 주장이 제공된 증거에 의해 뒷받침되는지 확인하는 작업을 맡길 수 있습니다.
프로젝트의 README를 바탕으로 작성되었습니다. 모든 활용 사례는 해당 내용의 인용문과 대조하여 확인합니다.
jevcore MCP 설치 방법
형식 확인: 2026년 11월 10일Cursor에 추가Goose에 추가Claude Code에 jevcore MCP 설치
$ claude mcp add jevcore -- npx -y jevcore-mcpCursor에 jevcore MCP 설치
~/.cursor/mcp.json
{
"mcpServers": {
"jevcore": {
"command": "npx",
"args": [
"-y",
"jevcore-mcp"
]
}
}
}VS Code에 jevcore MCP 설치
.vscode/mcp.json
{
"servers": {
"jevcore": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"jevcore-mcp"
]
}
}
}VS Code CLI에 jevcore MCP 설치
$ code --add-mcp '{"name":"jevcore","type":"stdio","command":"npx","args":["-y","jevcore-mcp"]}'Claude Desktop에 jevcore MCP 설치
claude_desktop_config.json
{
"mcpServers": {
"jevcore": {
"command": "npx",
"args": [
"-y",
"jevcore-mcp"
]
}
}
}Codex에 jevcore MCP 설치
$ codex mcp add jevcore -- npx -y jevcore-mcpCodex config.toml에 jevcore MCP 설치
~/.codex/config.toml
[mcp_servers.jevcore] command = "npx" args = ["-y", "jevcore-mcp"]
Gemini CLI에 jevcore MCP 설치
$ gemini mcp add -s user jevcore npx -- -y jevcore-mcpGemini settings.json에 jevcore MCP 설치
~/.gemini/settings.json
{
"mcpServers": {
"jevcore": {
"command": "npx",
"args": [
"-y",
"jevcore-mcp"
]
}
}
}자동 검사
2026년 11월 12일에 실행됨전체 보고서 →자동 검사를 통과했습니다. 이는 보안 감사가 아닙니다. 코드를 직접 읽고 서버에 필요한 최소한의 권한만 부여하십시오. 검사 방식
- 소스 저장소 연결 및 접근 가능통과
- 오픈 소스 라이선스 (OSI)통과
- 최근 1년 내 커밋 또는 릴리스통과
- 패키지 이름이 인기 패키지와 유사하지 않음통과
- 원격 엔드포인트가 HTTPS 사용검사되지 않음
- 파괴적인 도구에 라벨 표시됨검사되지 않음
- 모델에 대한 숨겨진 지침 없음통과
- 패키지 및 해당 종속성에 중요한 보안 권고 없음검사되지 않음
README
GitHub에서 보기jevcore
TypeSafe Jev for DeepSeek Harness and any other MCP host.
Jev is not a chat model. It answers typed questions — noul (yes/no), choice, score — and returns
calibrated probabilities. It does not write prose, and asking it to is a category error. This project
gives an agent exactly that surface, and nothing more.
Offline by default. Egress disclosed. Nothing default-on.
📖 Ecosystem knowledge base — measured data, not marketing: plugin development guide · plugin-selection data · maintenance criteria.
⭐ 如果它帮到了你
这个插件是 DSH 插件家族的一员(95 个,全部 Apache-2.0)。如果你在用,给个 star —— 它不会解锁任何功能,但会让下一个人在搜索里更容易找到它。
English: part of a 95 plugin family for DeepSeek Harness. If it is useful, a star helps the next person find it — nothing is gated behind it.
Three packages, one decision layer
| Package | What it is | Use it when |
|---|---|---|
jevcore |
The decisions. Imports nothing from DeepSeek Harness or Cordis. | You want Jev in a plain script, a service, or your own harness |
jevcore-dsh |
The DSH plugin: one service, three tools, two opt-in gates | You are running DeepSeek Harness |
jevcore-mcp |
The same three tools over MCP, with a stdio binary | Your host speaks MCP but is not DSH |
The adapters are thin on purpose. packages/dsh is four files: it declares tool schemas and
translates hook payloads. Everything decision-shaped — the primitives, the providers, the egress
contract, the policy, the gates — lives in core, so a new adapter cannot drift from the guarantees
the others make.
One runtime requirement differs across the three: jevcore-dsh tracks the harness and needs
Node ^22.19.0 || >=24.0.0, while jevcore and jevcore-mcp need >=20.
Why this exists
Between 2026-09-17 and 09-20, nineteen plugins appeared that wire Jev into DSH. Auditing their source found a consistent pattern: the module labelled guard, gate, or warden was also the module shipping prompts, tool arguments, and file contents to a third party, and the README generally did not say so. Several were enabled by default. One gate could be reconfigured by the model it was guarding.
This project is the same idea with those failure modes designed out:
| Property | How it is guaranteed here |
|---|---|
| No network call unless you ask for one | Default provider is an offline mock; the live path needs both provider: live and a resolved credential |
| Every transmission named before it happens | One startup log line per feature: off or SENDS <feature> { fields } |
| Gates register nothing when disabled | Verified by test, not by policy — a disabled gate adds no event listener at all |
| The model cannot widen its own constraints | No tool exposes gate configuration |
| A judge that cannot answer never means "allow" | Undecided resolves through explicit config, defaulting to ask |
The egress contract
This is the part worth reading before installing.
Transmission is decided per feature, and every feature defaults to off. The plugin prints its own contract at load:
[jevcore] provider=mock endpoint=none egress=OFF (no network calls will be made; every answer is synthetic)
[jevcore] ready - provider=mock - gates: safety=off context=off
With provider: live and every feature enabled, the same report becomes explicit about what leaves:
[jevcore] provider=live endpoint=https://api.typesafe.ai egress=ON
[jevcore] SENDS tool:jev_ask { state<=16000c questions<=4000c }
[jevcore] SENDS tool:jev_rank { state<=16000c questions<=4000c }
[jevcore] SENDS tool:jev_check { state<=16000c questions<=4000c }
[jevcore] SENDS gate:safety { state<=8000c questions<=2000c }
[jevcore] SENDS gate:context { state<=6000c questions<=2000c }
[jevcore] redaction is best-effort; it removes named fields and known secret shapes, and cannot
recognise an unrecognised secret in free text
| Feature | Off by default? | What it sends |
|---|---|---|
tool:jev_ask |
runs when the model calls it | the arguments the model passed, after redaction |
tool:jev_rank |
runs when the model calls it | the query plus every candidate |
tool:jev_check |
runs when the model calls it | the claim and its evidence |
gate:safety |
yes — explicit opt-in | the tool name, its arguments, the workspace root |
gate:context |
yes — explicit opt-in | a large tool result the agent just received |
The tools transmit only when the model chooses to call them, which is visible in the transcript. The gates would run on every matching tool call, which is not, so they are opt-in.
Redaction, and its honest limit
Before anything is sent, src/redact.ts runs two passes: values under sensitive field names
(password, token, apiKey, authorization, …) are replaced wholesale, and secret-shaped strings
that survive into free text are pattern-matched (Bearer …, sk-…, ts_live_…, AWS/GitHub/Google
key shapes, JWTs, private-key headers, credentials in connection strings).
This is a mitigation, not a permission. A secret that sits under an unrecognised key name and does not match a known shape will pass through. If that possibility is unacceptable for your workload, do not enable the live provider.
Install
As a DeepSeek Harness plugin
dsh plugin --profile <profile> add jevcore-dsh
Or from a checkout:
dsh plugin --profile <profile> add /absolute/path/to/jevcore/packages/dsh
packages/dsh imports jevcore by name, so a checkout also needs core
resolvable from the profile (add /absolute/path/to/jevcore/packages/core).
Then confirm the row activated — the plugin list should show jev as active,
not failed — and check the startup report in the log.
As an MCP server
For a host that speaks MCP, the same three tools are available over stdio:
npx -y jevcore-mcp
To wire it into DeepSeek Harness specifically, install a configuration-only bundle whose patch inserts the harness's own MCP client:
- insert:
- id: jev-mcp
name: '@deepseek-ai/dsh-mcp-client'
config:
serverName: jev
transport: stdio
command: npx
args: ['-y', 'jevcore-mcp']
env:
TYPESAFE_API_KEY: '<the key>'
failOnStartupError: true
The env map is not optional: DSH strips every credential-shaped name — anything containing KEY, PASSWORD, SECRET or TOKEN, in any case — from the environment it hands a spawned server, then merges this map back in afterwards. A key exported in your shell never arrives, and the server stays on the offline mock without reporting an error.
The provider is chosen from the environment:
| Variable | Effect |
|---|---|
TYPESAFE_API_KEY |
Selects the TypeSafe route when present |
OPENROUTER_API_KEY |
Selects the OpenRouter route when present and no TypeSafe key is set |
JEV_PROVIDER |
mock, live, or openrouter — overrides the heuristic above |
TYPESAFE_MODEL / OPENROUTER_MODEL |
Model id for the selected route |
TYPESAFE_BASE_URL / OPENROUTER_BASE_URL |
API root for the selected route |
With neither key it stays on the offline mock. Unlike the plugin, the MCP server
resolves its credential once at startup, so a missing key with
JEV_PROVIDER=live is a startup error rather than a per-call surprise.
Its egress report goes to stderr, never stdout — on a stdio transport stdout is the protocol channel, and a stray line there would corrupt the stream.
Going live
There are two routes to Jev. Both call the same models and both return the same typed answers; they differ in who holds your credential and whose servers see your state.
TypeSafe directly — use this if you have a key from console.typesafe.ai:
- insert:
- id: jev
name: 'jevcore-dsh'
config:
provider: live
apiKeyRef: TYPESAFE_API_KEY # a reference, never the key
model: jev-latest
Through OpenRouter — use this if a TypeSafe key is impractical and you
already have an OpenRouter key. OpenRouter serves the
System One models at the same POST /v1/systemone path TypeSafe does, one level
below its own API root, so this is the documented route to Jev rather than an
approximation of it:
- insert:
- id: jev
name: 'jevcore-dsh'
config:
provider: openrouter
openRouterApiKeyRef: OPENROUTER_API_KEY
model: jev-latest # a bare `jev-*` id, or `typesafe/jev-1.13`
The route is reached by pointing the official @typesafe-ai/sdk at
https://openrouter.ai/api with your OpenRouter key — OpenRouter's own
documented integration, so there is no second client to keep in step.
Two things to know about the OpenRouter route:
- Your state goes to OpenRouter, not to TypeSafe. A different third party with different retention and logging. The startup report names the endpoint for exactly this reason — read it rather than inferring the destination from the provider's name.
- It returns a cost, which TypeSafe's own route does not, so
usage.costUsdis populated here and absent there.
The model id must be a System One one. jev-latest bare is the default and needs
no prefix; typesafe/ is accepted on a versioned id such as typesafe/jev-1.13,
but not on the moving tag — typesafe/jev-latest is not accepted by the route.
Any other id would be routed to a chat model, which answers with prose this plugin
cannot interpret as a decision, so it is refused before the call rather than
misread after it.
Either way the credential is resolved through DSH's credential service first,
then the environment variable of that name. It is read per call, so a key added
while the process is running is picked up. It is never logged, never returned
from a tool, and never written to configuration. Each route has its own reference
(apiKeyRef and openRouterApiKeyRef) so the two cannot accidentally share a key.
@typesafe-ai/sdk is the only optional dependency; the plugin
loads and runs offline without either, and only needs the one for the route you
choose.
Configuration
| Key | Default | Meaning |
|---|---|---|
provider |
mock |
mock (offline, deterministic, synthetic), live (TypeSafe), or openrouter |
apiKeyRef |
TYPESAFE_API_KEY |
Credential reference for the live route |
openRouterApiKeyRef |
OPENROUTER_API_KEY |
Credential reference for the openrouter route |
baseURL |
https://api.typesafe.ai |
API root for the live route. Non-HTTPS is refused except on loopback |
openRouterBaseURL |
https://openrouter.ai/api |
API root for the openrouter route. Same rule |
model |
jev-latest |
Sent with every request. On the OpenRouter route the bare default works; typesafe/ needs a versioned id such as typesafe/jev-1.13, and typesafe/jev-latest is not accepted |
logLevel |
warn |
silent | warn | info | debug |
minConfidence |
0.7 |
Below this, an answer is not acted on |
minProbability |
0.6 |
Below this, a decision is not acted on |
maxStateChars |
per feature | Replaces the state cap for every feature. 0 means "keep the declared cap" |
gates.safety |
false |
Judge tool calls before dispatch |
gates.context |
false |
Withhold large, uninformative tool results |
The declared state caps are 16,000 characters for the three tools and 8,000 / 6,000 for the safety
and context gates. maxStateChars replaces all of them, and the startup report shows the effective
value rather than the declared one, so what it prints is what is enforced.
Gates accept a bare boolean (safety: false) or an object with onUndecided: ask (default),
allow, or deny.
ask is a question, so it needs something to ask. A deployment that composes no approval service
cannot escalate to a human, and DeepSeek Harness then refuses the call instead of running it: every
tool the safety gate matches is refused, which an operator experiences as the plugin having broken
shell commands. docs/approval.md has the mechanism, and the plugin README covers
the deployment view.
An unknown value is rejected at load with a message naming the key, rather than being silently ignored — a config typo should not quietly change the privacy posture.
Using it
From another plugin, with no model in the loop
The service is the primary surface. This is the point of a decision model: a routing or gating decision should not cost a model round-trip.
const jev = ctx.get('jev')
const result = await jev.ask({
feature: 'tool:jev_ask',
state: { ticket: 'I was charged twice.' },
questions: {
urgent: { type: 'noul', instructions: 'Does this convey urgency?' },
team: {
type: 'choice',
instructions: 'Which team should handle this?',
criteria: { billing: 'Payments, invoices, refunds', technical: 'Bugs, outages' },
},
},
})
result.answers carries probabilities and confidence. Deciding what to do with them is your code's
job — see src/policy.ts for a worked example with an explicit confidence floor, where an unsure
answer produces ask rather than allow.
From the model
Three tools, deliberately few and orthogonal:
jev_ask— a batch of typed questions over one state.jev_rank— score and sort candidates against one criterion, one question per candidate in a single round-trip. The probabilities are independent per-candidate judgments, not a distribution.jev_check— does this evidence support this claim? Returnssupported,contradicted,conflicted,insufficient,undecided, orunknown. Contradiction outranks support, because evidence that both supports and refutes is a conflict, not a weak yes.
A bundled skill
The plugin registers a skill, typesafe-ai-dsh, teaching an agent when a Jev
judgment is the right tool and when it is a category error. It is registered
through the skill registry rather than shipped as a directory for a provider to
scan, so it needs no dependency on where a profile keeps its skills and it
disappears cleanly when the plugin is removed.
The body lives in skills/typesafe-ai-dsh/SKILL.md and is read at load rather
than embedded, so the file a human edits is the file that ships. A test asserts
the two cannot drift.
The registry is declared as an optional dependency: a profile that does not compose the skill subsystem still gets the service and the three tools, with a warning that the skill was skipped.
The mock provider
With provider: mock, every answer is derived from a hash of the question and state, so tests can
assert exact values and no socket is opened. Synthetic results are labelled as such in three places:
provider: "mock", a mock/jev-synthetic model name, and a warning field on the result. A mock
that could be mistaken for a real judgment would be worse than no mock at all.
Status
Honest accounting of what has and has not been verified.
Verified
- 410 tests pass across three packages (314 core, 66 DSH, 30 MCP), with no network access and no
TYPESAFE_API_KEY. CI clears the variable and expects the suite to pass anyway. - The OpenRouter route is verified against the real API.
pnpm --filter jevcore run probe:livedrives the provider andpnpm --filter jevcore-mcp run smoke:livedrives the whole MCP surface — transport, tool schemas, service and provider — against real System One models (typesafe/jev-1.13-20260917). A three-primitive batch returned anoulat 0.91, achoiceat 0.97, and ascoreof1.05on a four-level rubric, with usage reported as{ inputTokens: 469, outputTokens: 68, costUsd: 0.000019698 }.jev_rankordered a credential runbook above a billing guide;jev_checkreturnedcontradicted. Both scripts needOPENROUTER_API_KEYand are excluded from CI. - The payload shapes are checked against the vendors' own type definitions.
test/vendor-conformance.test.tspins this project's question and answer types to both SDKs, so a drift in either direction is a compile error rather than a malformed request on the one route that costs money and transmits data. That check is what foundscore.criteriabeing sent as a keyed map when the API requires an ordered array — a defect the stubbed unit tests had passed over throughout. There is also a script that parsed our payloads against OpenRouter's published zod schemas for thealpha/decisionsroute; both the script and that route are gone, because the OpenRouter provider now uses the documented/v1/systemonepath through the same client TypeSafe uses, which the conformance test already covers. - The plugin activates in a running harness and its tools work. The plugin row reports
active;jev_askreturnedurgent=true (0.8307)andteam=billing (0.5027)against the mock in 1 ms, andjev_checkreturnedverdict="insufficient"with its three probabilities. Every result carriedprovider: "mock"and zero token usage, so the default path made no network call. - The bundled skill registers.
typesafe-ai-dshappears in the session skill catalog. - The default path makes no network call: asserted by spying on
globalThis.fetchwhile mounting the plugin and answering through the service, and again while assembling the MCP runtime. - A disabled gate registers no event listener, and a denied egress never reaches the provider.
Configsatisfies the Standard Schema protocol Cordis requires before a plugin starts.- Every DSH API used here (
ctx.provide,ctx.effect,tools.register,defineTool,tools/pre-execute,tools/post-execute,credentials.resolve) was checked against the installed runtime before use, and the payload types come from the installed declaration files.
Not verified, or known-broken
- The TypeSafe route is exercised, but only lightly.
packages/core/scripts/probe-live.mjs(pnpm --filter jevcore run probe:typesafe) asks the real API three things: ten claim/evidence pairs whose verdict is known in advance, one question repeated six times, and a noul carrying acriteria: {true, false}boundary. Two separate runs agreed — supporting evidence scored 0.95, contradicting evidence 0.10, evidence silent about the claim 0.03, and the repeated question varied by 0.01 or less. The boundary was accepted. What remains untested is everything around the request rather than the request itself: quota, rate-limit and entitlement behaviour on a real account. jev_ask's description carries a corrupted dash on the build that is currently running. It readsbranches on —?routingwhere an em dash followed by a space belongs. Cause: a UTF-8 round-trip early in development replaced the third byte of the em dash with?. It is fixed on disk — four occurrences, zero remaining, confirmed in both source and build output — but the running process loaded its module before the fix and cannot re-read it without a restart. The dash itself is cosmetic, but the staleness is not: the same process also lacks every fix made since it started, including thebandfield that keeps a 0.51 from being read as a settled yes.- The MCP server has been driven end to end by a real MCP client over stdio
(
pnpm --filter jevcore-mcp run smoke): handshake, tool discovery, three successful calls, and an error result for an invalid batch. It has not been driven by any other third-party host. - Gate behaviour on live traffic. The gates are tested against synthetic answers and real hook payload shapes, but no real tool call has been gated end to end.
- The context gate cannot recover context already spent. It withholds a result from reaching the agent; it does not prune anything retroactively, and the README of any plugin claiming otherwise should be read sceptically.
- No long-running or adversarial testing. Redaction is pattern-based and will miss an unrecognised secret shape.
Design notes
Three decisions that are easy to get wrong and expensive to get wrong:
A judge that cannot answer must not mean "allow". If Jev is unreachable, or answers below the
confidence floor, the gates resolve through onUndecided, which defaults to ask. The only way to
get fail-open behaviour is to configure it. The context gate is the deliberate exception: it fails
open unconditionally, because losing a real tool result to a phantom "irrelevant" verdict is worse
than keeping an uninformative one.
Nothing the model can say changes the gate. No tool exposes gate configuration, thresholds, or scope. A guard the guarded process can reconfigure is not a guard.
A probability is not a permission. Jev returns numbers; src/policy.ts turns them into
allow/ask/deny against locally configured thresholds. An answer that names a value outside the
declared criteria is invalid and denies — the guarantee of a typed decision model is that it cannot
return an undeclared value, so a violation means something upstream is wrong.
Development
pnpm install
pnpm run check # typecheck + tests + build
pnpm test # tests only
No test requires a credential or a network connection, and CI enforces that by running with
TYPESAFE_API_KEY cleared.
jevcore MCP 질문
jevcore MCP를 Claude Code에 추가하려면 어떻게 하나요?
터미널에서 claude mcp add jevcore -- npx -y jevcore-mcp를 실행합니다. 모든 프로젝트에서 사용할 수 있게 하려면 --scope user를 추가합니다.
jevcore MCP를 Cursor에 추가하려면 어떻게 하나요?
~/.cursor/mcp.json를 열고 mcpServers 아래에 서버를 추가합니다. 위 설치 섹션에 표시된 Cursor 구성을 사용합니다.
jevcore는 오프라인에서 작동하나요?
네. 기본 제공되는 프로바이더는 오프라인 모크(mock)로, 네트워크 호출 없이 합성된 답변을 반환합니다.
jevcore를 MCP server로 어떻게 설치하나요?
npx를 통해 stdio로 실행하거나, npx -y jevcore-mcp 명령어를 사용하여 MCP host 설정에 연결하십시오.
jevcore는 어떤 API key를 사용하나요?
TypeSafe 경로를 위해서는 TYPESAFE_API_KEY를, OpenRouter 경로를 위해서는 OPENROUTER_API_KEY를 읽습니다. 두 키가 모두 없으면 오프라인 모크 상태를 유지합니다.
jevcore가 모델에 제공하는 도구는 무엇인가요?
jev_ask, jev_rank, jev_check 세 가지 도구를 제공하며, 각 도구는 산문 형태가 아닌 타입이 지정된 답변을 반환합니다.
jevcore는 데이터를 전송하기 전에 비밀 정보를 마스킹하나요?
민감한 필드 값과 알려진 비밀 정보 형태는 마스킹하지만, 인식되지 않은 이름이나 형태의 비밀 정보는 그대로 전달될 수 있습니다.