OP

openevidence-security-basics

Implementation guide for HIPAA-compliant handling of OpenEvidence API keys and patient data.

Install

mkdir -p .claude/skills/openevidence-security-basics && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/8157" && unzip -o skill.zip -d .claude/skills/openevidence-security-basics && rm skill.zip

Installs to .claude/skills/openevidence-security-basics

Activation

This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.

Security Basics for OpenEvidence.
33 charsno explicit “when” trigger
Intermediate

Key capabilities

  • Manage OpenEvidence API keys in secure environments
  • Verify webhook signatures using HMAC-SHA256
  • Validate clinical queries against predefined schemas
  • Redact PHI from application logs
  • Enforce TLS 1.2+ for data in transit

How it works

The skill enforces security by providing code patterns for API key management, webhook verification, and field-level PHI redaction. It mandates the use of HIPAA-compliant secrets managers and TLS encryption for all clinical data.

Inputs & outputs

You give it
Clinical query data or webhook request
You get back
Validated query or verified webhook signature

When to use openevidence-security-basics

  • Implement HIPAA-compliant API security
  • Secure webhook communication
  • Configure environment variables for secrets
  • Audit access logs for clinical data

About this skill

OpenEvidence Security Basics

Overview

OpenEvidence provides AI-powered clinical evidence synthesis that processes protected health information (PHI), patient queries, and medical literature references. Integrations must comply with HIPAA requirements for PHI handling, audit logging, and access controls. A breach exposes patient health questions, clinical recommendations, and potentially identifiable medical conditions. Every API interaction must be treated as a HIPAA-regulated transaction.

API Key Management

function createOpenEvidenceClient(): { apiKey: string; baseUrl: string } {
  const apiKey = process.env.OPENEVIDENCE_API_KEY;
  if (!apiKey) {
    throw new Error("Missing OPENEVIDENCE_API_KEY — store in HIPAA-compliant secrets manager");
  }
  // PHI-adjacent access — enforce audit logging on every request
  console.log("OpenEvidence client initialized (key suffix:", apiKey.slice(-4), ")");
  return { apiKey, baseUrl: "https://api.openevidence.com/v1" };
}

Webhook Signature Verification

import crypto from "crypto";
import { Request, Response, NextFunction } from "express";

function verifyOpenEvidenceWebhook(req: Request, res: Response, next: NextFunction): void {
  const signature = req.headers["x-openevidence-signature"] as string;
  const secret = process.env.OPENEVIDENCE_WEBHOOK_SECRET!;
  const expected = crypto.createHmac("sha256", secret).update(req.body).digest("hex");
  if (!signature || !crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected))) {
    res.status(401).send("Invalid signature");
    return;
  }
  next();
}

Input Validation

import { z } from "zod";

const ClinicalQuerySchema = z.object({
  query_id: z.string().uuid(),
  clinical_question: z.string().min(10).max(2000),
  specialty: z.enum(["oncology", "cardiology", "neurology", "general", "pediatrics", "emergency"]).optional(),
  evidence_level: z.enum(["systematic_review", "rct", "cohort", "case_report", "expert_opinion"]).optional(),
  include_guidelines: z.boolean().default(true),
});

function validateClinicalQuery(data: unknown) {
  return ClinicalQuerySchema.parse(data);
}

Data Protection

const OPENEVIDENCE_PHI_FIELDS = ["patient_name", "date_of_birth", "mrn", "clinical_question", "diagnosis", "medication_list"];

function redactOpenEvidenceLog(record: Record<string, unknown>): Record<string, unknown> {
  const redacted = { ...record };
  for (const field of OPENEVIDENCE_PHI_FIELDS) {
    if (field in redacted) redacted[field] = "[REDACTED_PHI]";
  }
  return redacted;
}

Security Checklist

  • API keys stored in HIPAA-compliant secrets manager
  • Separate keys per environment (dev/staging/prod)
  • Key rotation scheduled quarterly
  • HIPAA audit logging enabled on every API call
  • PHI never logged in application logs (field-level redaction)
  • BAA (Business Associate Agreement) on file with OpenEvidence
  • Clinical query data encrypted at rest and in transit (TLS 1.2+)
  • Access controls enforce minimum necessary PHI exposure

Error Handling

VulnerabilityRiskMitigation
Leaked API keyUnauthorized access to clinical evidence queriesHIPAA-compliant secrets manager + rotation
PHI in application logsHIPAA violation and patient data exposureMandatory PHI field redaction
Missing BAARegulatory non-compliance penaltyBAA signed before integration goes live
Unencrypted clinical dataPHI breach during transit or storageTLS 1.2+ in transit, AES-256 at rest
Missing audit trailHIPAA audit failureImmutable audit logs for all API interactions

Resources

Next Steps

See openevidence-prod-checklist.

When not to use it

  • Logging PHI in application logs
  • Storing API keys without a secrets manager

Prerequisites

Business Associate Agreement (BAA) with OpenEvidence

Limitations

  • PHI must never be logged in application logs
  • BAA must be signed before integration goes live

How it compares

This approach provides specific code-level security controls for PHI handling rather than generic API security practices.

Compared to similar skills

openevidence-security-basics side by side with the closest alternatives in the catalog.

SkillInstallsUpdatedSafetyDifficulty
openevidence-security-basics (this skill)027dReviewIntermediate
apollo-security-basics127dCautionIntermediate
auth-implementation-patterns14moNo flagsAdvanced
maintainx-enterprise-rbac127dReviewAdvanced

Try saying

Example prompts that trigger this skill in your AI assistant.

More by jeremylongshore

View all by jeremylongshore

analyzing-logs

jeremylongshore

Analyze application logs to detect performance issues, identify error patterns, and improve stability by extracting key insights.

14123

ollama-setup

jeremylongshore

Configure auto-configure Ollama when user needs local LLM deployment, free AI alternatives, or wants to eliminate hosted API costs. Trigger phrases: "install ollama", "local AI", "free LLM", "self-hosted AI", "replace OpenAI", "no API costs". Use when appropriate context detected. Trigger with relevant phrases based on skill purpose.

1167

backtesting-trading-strategies

jeremylongshore

Backtest crypto and traditional trading strategies against historical data. Calculates performance metrics (Sharpe, Sortino, max drawdown), generates equity curves, and optimizes strategy parameters. Use when user wants to test a trading strategy, validate signals, or compare approaches. Trigger with phrases like "backtest strategy", "test trading strategy", "historical performance", "simulate trades", "optimize parameters", or "validate signals".

1071

generating-database-seed-data

jeremylongshore

Process this skill enables AI assistant to generate realistic test data and database seed scripts for development and testing environments. it uses faker libraries to create realistic data, maintains relational integrity, and allows configurable data volumes. u... Use when working with databases or data models. Trigger with phrases like 'database', 'query', or 'schema'.

1033

cursor-codebase-indexing

jeremylongshore

Execute set up and optimize Cursor codebase indexing. Triggers on "cursor index setup", "codebase indexing", "index codebase", "cursor semantic search". Use when working with cursor codebase indexing functionality. Trigger with phrases like "cursor codebase indexing", "cursor indexing", "cursor".

885

testing-mobile-apps

jeremylongshore

Execute mobile app testing on iOS and Android devices/simulators. Use when performing specialized testing. Trigger with phrases like "test mobile app", "run iOS tests", or "validate Android functionality".

810

You might also like

apollo-security-basics

jeremylongshore

Apply Apollo.io API security best practices. Use when securing Apollo integrations, managing API keys, or implementing secure data handling. Trigger with phrases like "apollo security", "secure apollo api", "apollo api key security", "apollo data protection".

13

auth-implementation-patterns

sickn33

Master authentication and authorization patterns including JWT, OAuth2, session management, and RBAC to build secure, scalable access control systems. Use when implementing auth systems, securing APIs, or debugging security issues.

12

maintainx-enterprise-rbac

jeremylongshore

Configure enterprise role-based access control for MaintainX integrations. Use when implementing SSO, managing organization-level permissions, or setting up enterprise access controls with MaintainX. Trigger with phrases like "maintainx rbac", "maintainx sso", "maintainx enterprise", "maintainx permissions", "maintainx roles".

11

juicebox-security-basics

jeremylongshore

Apply Juicebox security best practices. Use when securing API keys, implementing access controls, or auditing Juicebox integration security. Trigger with phrases like "juicebox security", "secure juicebox", "juicebox API key security", "juicebox access control".

10

api-security-hardening

aj-geddes

>

00

vercel-webhooks-events

jeremylongshore

Implement Vercel webhook signature validation and event handling. Use when setting up webhook endpoints, implementing signature verification, or handling Vercel event notifications securely. Trigger with phrases like "vercel webhook", "vercel events", "vercel webhook signature", "handle vercel events", "vercel notifications".

325

Search skills

Search the agent skills registry