novainsilico/jinko-skills

jinko-context

Explain core Jinkō context, navigation, version management, and domain language for agents and users.

Voir la source

Mode d’emploi

  1. Copiez la commande et examinez le paquet avant de l’installer dans votre environnement agent.
  2. Consultez le document original pour les outils, identifiants et environnements requis.
  3. Décrivez les entrées et le livrable souhaité ; comparez la sortie aux sources.
npx skills add https://github.com/novainsilico/jinko-skills --skill jinko-context

Avant de commencer

  • L’installation n’inclut ni abonnement au modèle, ni quota API, ni accès aux fichiers.
  • Étoiles et installations reflètent l’activité, pas un test indépendant de qualité ou de sécurité.
Document Skill original

Rendu depuis le dépôt source en conservant titres, exemples, code, tableaux, liens et images.

Jinkō Context

Use this skill to explain Jinkō's shared mental model and vocabulary. Keep answers practical: the goal is to help a user or agent navigate Jinkō artifacts without confusing project organization, scientific content, and immutable versions.

PREREQUISITE: The folder-management example needs an initialized jinko- sdk connection and an SDK satisfying its metadata.requires_sdk range. Run the jinko-sdk-setup skill (../jinko-sdk-setup/SKILL.md) and proceed only once its check passes. Use JINKO_API_KEY when it is set. Only without a key, call get_session_code again before this skill's own SDK process, because a session code can be exchanged only once. If that skill is not found, install it from novainsilico/jinko-skills.

Navigation and Version Management

Jinkō project navigation behaves much like working in a Git repository, but for scientific modeling artifacts instead of source-code files.

  • A Project is like the repository: it is the boundary for a concrete scientific modeling effort, including references, data, models, protocols, trials, reports, and collaboration history.
  • Folders are like repository directories: they organize related project items by workflow, experiment, disease area, evidence package, or analysis thread. The folder API is an organizational surface; a folder is not a Project Item.
  • Project Items are like tracked files or domain objects in the repository: each item has an SID and represents a Jinkō artifact such as a model, protocol, trial, data table, reference, output set, or document.
  • Snapshots are immutable states exposed by versioned Jinkō core-item APIs. The latest state is head. Do not assume every Project Item type exposes snapshots; use the resource's SDK/API surface to determine whether snapshot identity exists.

This Git-like structure makes Jinkō easier for agents to navigate because agents can separate three questions:

  • Where is the work organized? Look at the project and folders.
  • Which artifact is being discussed? Identify the project item.
  • Which exact state of a versioned artifact matters? Use its explicit version or snapshot surface, or use head when the user wants the latest state.

Use Project, Project Item, and Snapshot rather than generic words like workspace, file, upload, save, version, revision, or commit unless you are explicitly making the Git analogy.

Iterate on the same project item

When you refine the same experiment, edit the existing Project Item and save a named version, like a Git commit on the same file. Do not create a second item for each attempt. Earlier versions stay available, so the version history shows each iteration.

  • Create a new Project Item only for the first creation, an independent scenario that the user asks for, or a type that cannot be edited (for example, a generated Vpop).
  • Give each version a short name with the version= argument, for example version="fix dosing event timing".
  • A Trial or Calibration keeps the exact Snapshot of each component that it was given. After you edit a model, protocol, output set, vpop, or data table, call set_components(...) on the Trial or Calibration that uses it. This saves a new version that uses the latest Snapshot. Then run it again.
  • Before you create an item, state why an edit of the existing item is not possible.

Read references/iteration.md for the update method of each Project Item type.

Domain Language

Project: A concrete scientific modeling effort with its own References, data, modeling artifacts, and reports. Avoid: workspace, case, study folder.

Folder: An organizational container inside a project used to group related project items. Folders support navigation and workflow hygiene; they do not replace item identity or snapshot identity. Avoid: Project Item or directory when speaking to end users unless making the Git analogy.

Project Item: A named Jinkō object inside a project, such as a Reference, model, protocol, trial, data table, output set, or document. Its SID is the preferred user-facing identity. Versioned types can retain that identity across versions. Avoid: file, asset, object when precision matters.

Snapshot: An immutable state of a Jinkō model, protocol, trial, or other resource whose core-item API exposes snapshots. It enables exact version access; it is not a universal property of folders or every Project Item type. Avoid: revision, save, version, commit except when explaining the analogy.

Reference: A Project Item that holds a source PDF, usually a scientific paper, and its bibliography metadata, such as the DOI. It is the evidence for extraction and modeling. The Jinkō API type name of this item is Source. Avoid: source, document, file, upload. Use Source only for the API type name.

Extract: A Project Item that holds one selected textual, rectangular, formula, or data-table object from one Reference. It can carry a formulation that states the evidence, such as a parameter value, clinical endpoint, or mechanism statement, and a classification (Statement, Hypothesis, or Data). Avoid: note, snippet, untracked fact.

Highlight: A located piece of evidence inside an Extract. It links to its position in the Reference PDF. A Highlight is not a Project Item. Avoid: annotation, quote.

Model: A Jinkō-compatible executable representation of the biological or pharmacological mechanism being modeled. Avoid: model file, script.

Protocol: The Jinkō artifact that defines trial arms, interventions, dosing or treatment conditions, and simulation timing. Avoid: study design, scenario file.

Trial: The Jinkō artifact that combines a protocol, model, output sets, and data tables for simulation or comparison. Avoid: run, simulation setup.

Calibration: The stage that adjusts model parameters so simulations fit selected experimental evidence. Avoid: fitting, tuning.

Calibration Candidate: A model-intrinsic parameter proposed for calibration. It may be marked with a toCalibrate model tag. Avoid: free parameter, tuned knob.

Virtual Population: A generated population of parameterized virtual subjects used for in-silico trial execution. Avoid: cohort, sample.

Traceability Link: The link from a model, dataset, or report assertion back to the Extract, Reference, or explicit assumption that justifies it. Avoid: reference (that term names the Project Item), citation, provenance.

Modeling Context: The full scientific, protocol, trial, Reference, and artifact background needed to build or refine a Jinkō Model. Avoid: extraction catalog, model input bundle.

Relationships

  • A Project contains one or more Project Items.
  • A Folder organizes Project Items within a Project.
  • Some versioned Project Items expose Snapshots through their core-item APIs.
  • A Snapshot captures one immutable core-item state; consult the resource API rather than assuming one exists.
  • A Reference supports one or more Extracts.
  • An Extract comes from one Reference and holds its evidence as one or more Highlights.
  • A Highlight links to its position in the Reference PDF.
  • A Model represents executable biological or pharmacological mechanisms.
  • A Protocol defines arms, interventions, and timing used by a Trial.
  • A Trial uses a Protocol, a Model, output sets or measures, and optional transformed data overlays.
  • A Calibration uses selected evidence and outputs to adjust Calibration Candidates.
  • A Virtual Population provides parameterized virtual subjects for Trial execution.
  • A Traceability Link connects Project Items, Model components, Trial outputs, data tables, and reports back to Extracts, References, or explicit assumptions.
  • A Modeling Context gathers the relevant References, Extracts, Traceability Links, Models, Protocols, Trials, and reports needed to make a modeling decision.

Response Guidance

  • Translate user language into Jinkō language when it improves precision.
  • Preserve the Git analogy for orientation, but do not imply Jinkō is literally Git.
  • Distinguish stable SID identity from immutable snapshot identity where that resource exposes snapshots.
  • When the user iterates on the same experiment, recommend a new named version of the existing item, not a new item. See "Iterate on the same project item".
  • Use head/latest only when the user wants the current state; name snapshots when exact reproducibility matters.
  • When the user needs to inspect, create, or change folders, read references/folder-management.md and use its bundled script or the SDK calls it names rather than improvising API calls.
  • Route implementation tasks to the relevant skill: jinko-reference, jinko-model, jinko-protocol, jinko-trial, jinko-vpop, jinko-data-table, or jinko-sdk-setup.
du même dépôt

Autres Skills

Tous les Skills
novainsilico
Communauté

jinko-data-table

Create or inspect Jinkō data tables via the jinko-sdk. Use this skill whenever the user wants to upload observed data for trial overlays or calibration objectives from CSV, SQLite, or pandas DataFrame; check data-table schema columns; inspect existing data tables; or verify metadata.public.validForFitnessFunction. Do not use this skill for output sets; use jinko-output-set for that.

Installations / 1h
2
GitHub Stars
4
Mis à jour
16 nov.
novainsilico
Communauté

jinko-sdk-setup

Authenticate and configure access to a Jinkō project via the jinko-sdk. Use this skill whenever the user wants to connect to Jinkō, install the SDK, set up credentials or a .env file, verify API access, fail-fast check that a JINKOAPIKEY (preferred) or a JINKOSESSIONCODE works, choose the JINKOPROJECTID when the key reaches several projects, obtain a session code from the Jinko MCP getsessioncode tool when no API key is set, tell a project key from an organization key, choose between JinkoClient

Installations / 1h
2
GitHub Stars
4
Mis à jour
16 nov.
novainsilico
Communauté

jinko-task-cmaes

Execute a CMA-ES calibration from confirmed Jinkō inputs: assemble the model, protocol, output sets, fitness data tables, parameter priors, and optimizer options; create and run the Calibration; and return the supported results. Optionally, on request, qualify the parameter uncertainty of a completed CMA-ES calibration: identifiability, compensations, and prediction bands, in a Jinkō document. Use when the user wants to perform a CMA-ES calibration, or to check which calibrated parameters the da

Installations / 1h
2
GitHub Stars
4
Mis à jour
16 nov.
novainsilico
Communauté

jinko

- Discover and route Jinkō QSP and mechanistic-modeling requests to the public Jinkō skill that owns the work. Use when the user is starting a Jinkō session, asks what capability or skill to use, describes a multi-area modeling request, or has not yet identified the relevant jinko- or jinko-task- skill. This skill does not make scientific decisions, plan workflows, execute SDK calls, or decide that a task step is complete.

Installations / 1h
1
GitHub Stars
1
Mis à jour
7 sept.