/* very hacky way to be able to scroll to a specific step */
.scroll-anchor {
  position: relative;
  top: calc(-2rem - var(--scroll-mt));
}


/**
 * Checks that all the links in the docs are valid. Handrolled because the Mintlify link checker has too many false positives. Run `npm run check` or `node check_links.js` to run this script.
 *
 * Right now, we only verify that internal links (links that point to other docs pages) are valid.
 *
 * Including "lint:no-link-check" or "lint:no-link-check-next-line" anywhere in a line will disable link checking for that line or the subsequent line, respetively.
 *
 * We currently don't account for redirects. Our internal links shouldn't need a layer of redirection anyways, and we should instead just update them if we move pages around.
 *
 * Feel free to ping me (Ryan) if this script stops working.
 */

const fs = require("node:fs");
const path = require("node:path");
const process = require("node:process");
const config = require("./mint.json");

const DISABLE_LINK_CHECK = "lint:no-link-check";
const DISABLE_LINK_CHECK_NEXT_LINE = "lint:no-link-check-next-line";

const pages = config.navigation.flatMap((group) => group.pages);

function isBadLink(pagePath, link) {
  const url = new URL(link, `https://docs.devin.ai/${pagePath}`);

  if (link.includes("docs.devin.ai")) {
    return { error: "Links shouldn't include docs.devin.ai" };
  }
  if (url.hostname !== "docs.devin.ai") {
    return false;
  }

  return (
    !fs.existsSync(path.join(__dirname, url.pathname)) &&
    !fs.existsSync(path.join(__dirname, url.pathname + ".mdx"))
  );
}

function scrapeLinks(pageMdx) {
  const linkRegex = /\[([^\]]+)\]$([^)]+)$/g;
  const links = [];
  let match;

  const lines = pageMdx.split("\n");
  for (let i = 0; i < lines.length; i++) {
    if (lines[i].includes(DISABLE_LINK_CHECK) || (i && lines[i - 1].includes(DISABLE_LINK_CHECK_NEXT_LINE))) {
      continue;
    }

    while ((match = linkRegex.exec(lines[i])) !== null) {
      links.push(match[2]);
    }
  }

  return links;
}

function readPage(page) {
  return fs.readFileSync(path.join(__dirname, page + ".mdx"), "utf8");
}

let hasErrors = false;

for (const page of pages) {
  const pageMdx = readPage(page);
  const links = scrapeLinks(pageMdx);

  const badLinks = links.map((link) => ({link, error: isBadLink(page, link)})).filter(({error}) => error);

  if (badLinks.length > 0) {
    console.log(page + ".mdx");
    for (const {link, error} of badLinks) {
      if (Object.hasOwn(error, "error")) {
        console.log(`  ${link}: ${error.error}`);
      } else {
        console.log(`  ${link}`);
      }
    }
    console.log();
    hasErrors = true;
  }
}

if (hasErrors) {
  process.exit(1);
}


Create knowledge

bearerAuth

Knowledge created. Returns the newly created knowledge.

Example response for creating a knowledge

Unauthorized - Invalid or missing API key

Forbidden - User does not have permission to access the resource

Devin Docs

Devin is your collaborative AI teammate, built to help ambitious engineering teams achieve more.

Introducing Devin

Start your first session and see what Devin can do

Your First Session

Tutorial Library

When to Use Devin

Instructing Devin Effectively

Good vs. Bad Instructions

Set up Devin's workspace to start building

Repo Setup

Configure VPN access for Devin to connect to your internal network

VPN Configuration

Knowledge is a collection of instructions and advice that Devin can reference in all sessions. Think of it as onboarding a new employee with the relevant organizational context.

Knowledge Onboarding

Work with Devin to create detailed plans before Devin starts coding

Interactive Planning

Make edits and test Devin's code directly in its IDE

Devin IDE

A tool to rapidly answer questions about your codebase

Devin Search

Architecture diagrams, documentation, links to sources, and more for all your repos

Devin Wiki

Try our free version of Devin Wiki and Devin Search for public repositories

DeepWiki

Share important context and knowledge to help Devin get onboarded

Knowledge

Securely share credentials with Devin so it can access any tool

Secrets & Site Cookies

Interactive Browser

Build a library of reusable prompts for your organization

Creating Playbooks

Using Playbooks

Devin's abilities and limitations in deploying frontend and backend applications.

Deployments

Only available for Team and Enterprise plans

Invite your Team

Use your local settings and extensions while working in Devin's IDE

Importing Code Settings

GitHub Integration Guide

Chat and collaborate with Devin directly in your company Slack

Slack Integration Guide

Work with Devin directly in your GitLab repositories

GitLab Integration (Beta)

Work with Devin directly in your Azure DevOps repositories

Azure DevOps Integration (Beta)

Work with Devin directly in your Bitbucket repositories

Bitbucket Integration (Beta)

Assign Linear tickets to Devin and turn them into PRs

Linear Integration Guide

Assign Jira tickets to Devin and turn them into PRs

Jira Integration Guide

We want Devin to be a core contributor in your organization, and have prioritized security, data privacy and compliance to make it possible

Security at Cognition

Billing

Common Issues

Testing & Refactoring

Data & Analysis

Web Scraping & Automation

Interactive Applications

Migration & Modernization

Devin can integrate, configure, and test third party APIs in your applications.

API Integration

Devin can analyze your codebase's test suite and write additional tests to increase code coverage for your team.

Code Coverage

In this tutorial, we’ll show you how Devin can configure a Docker container to standardize your team’s dev environment.

Containerization

Devin can work with frontend libraries and share visuals with you during its sessions.

Managing Frontend Components

Learn how to programmatically create and manage Devin sessions using our REST API

Overview

Learn how to effectively use structured output and interact with Devin sessions via API

Structured Output

Code examples and common use cases for the Devin API

Usage Examples

List all Devin sessions for your organization.

List all sessions

Create a new Devin session. You can optionally specify parameters like snapshot ID and session visibility.

Create a new session

Retrieve detailed information about an existing Devin session, including its status, output, and metadata.

Retrieve details about an existing session

Send a message to an existing Devin session to provide additional instructions or information.

Send a message to an existing session

Upload files for Devin to work with during sessions. Supports various file types including code, data, and documentation files.

Upload files for Devin

Update the tags associated with a Devin session.

Update session tags

List metadata for all secrets in your organization. Does not return secret values.

List all secrets metadata

Permanently delete a secret by its ID. This action cannot be undone.

Delete a secret

Gets all knowledge and folders in your current organization. This endpoint will not return system knowledge (repo indexes or built-in knowledge) managed by Cognition.


List knowledge

Update the name, body, or trigger of a piece of knowledge.


Update knowledge

Permanently delete a piece of knowledge by its ID. This action cannot be undone.


API Reference

Session Endpoints

Secrets Endpoints

Knowledge Endpoints

Enterprise Endpoints

Create knowledge

Authorizations

Body

Response