The GenomeComputer Company
Back to tutorials

Tutorial

Build with .genome

Use .genome as a structured context layer for genome-aware products, agents, local tools, and developer workflows.

8 minAPI, MCP, Local code

What you will learn:

You will understand the main build paths: read files locally, expose tools through MCP, or integrate with the Genome API.

For developers, .genome is a context format. It gives an agent or application a structured way to work with genome data, annotations, sources, prompts, and evidence. Instead of asking a model to reason over raw sequencing files directly, you can build workflows around an AI-ready layer designed for exploration.

The core product idea is simple: a user should be able to keep their genome, inspect it, self-host it, delete data by default, and bring it into the tools they choose. Builders can use .genome to make that practical inside apps, agents, notebooks, or internal workflows.

Three build paths

  • Local files: read .genome files directly in a local app, notebook, or agent workspace.
  • MCP: expose genome-aware tools to AI clients that can call tools and retrieve context.
  • API: integrate ordering, conversion, retrieval, or product workflows programmatically.

Minimal genome-aware workflow

  1. Accept a user question.
  2. Identify the relevant genes, variants, annotations, sources, or prompts.
  3. Retrieve only the .genome context needed for that question.
  4. Ask the model to separate direct file evidence from interpretation.
  5. Return an answer with file references and source context.
  6. Store the prompt, output, and provenance for later review.

Agent design prompt

You are helping me design a genome-aware agent using a .genome bundle. First inspect the bundle structure and identify stable inputs, useful annotations, source fields, and prompt files. Propose a minimal workflow that answers one user question with file-grounded evidence and clear provenance.

Feature planning prompt

Design a small product feature that uses .genome as context. The feature should accept one user question, retrieve relevant genome annotations, ask an AI model for an evidence-grounded answer, and return a response that separates file evidence, source context, and interpretation.

Good first builds

  • A local gene lookup tool that searches a .genome bundle and produces a cited report.
  • A prompt runner that applies saved templates to new Genome Intelligence cards.
  • An MCP tool that retrieves relevant .genome context for an AI assistant.
  • A small app that turns a user question into a file-grounded genome exploration report.
  • A notebook that compares annotations across versions of a .genome bundle.

Design principles

  • Retrieve the smallest useful context, not the whole bundle by default.
  • Keep file evidence, source context, and model interpretation separate.
  • Make outputs auditable with file references and source fields.
  • Let users keep, export, self-host, or delete their data.
  • Treat prompts as product surface, not hidden implementation detail.

A good .genome application should make genome exploration feel inspectable. The user should know what data was used, what source supported the answer, what the model inferred, and how to rerun or improve the workflow.