# Docs Agent integrations

import { Aside, Steps } from '@astrojs/starlight/components';

Reference external content directly in your prompts. Instead of copying and pasting, mention a Slack thread, Notion page, or ticket ID, and the agent pulls the content automatically.

## Available integrations

| Integration | What you can reference |
|-------------|------------------------|
| **GitHub** | Pull request context, code diffs, and file changes |
| **GitLab** | Merge requests, issues, and repository files |
| **Slack** | Messages and threads |
| **Notion** | Pages and databases |
| **Linear** | Issues, descriptions, and comments |
| **Jira** | Issues, descriptions, and comments |
| **Confluence** | Pages and spaces |
| **Google Drive** | Files, folders, and documents |
| **PostHog** | Product analytics, feature flags, and HogQL queries |

## Connect an integration

<Steps>
1. Go to **Settings > Organization > Integrations** in your EkLine dashboard.
2. Find the integration you want to connect.
3. Click **Connect** and complete the authorization using an OAuth 2.0 popup or token entry, depending on the integration.
4. The integration is now available in all Docs Agent sessions.
</Steps>

Each team member connects their own account. The agent can only access content you have permission to view.

## GitHub

Trigger Docs Agent directly from pull request comments. Mention `@ekline-ai` on any PR comment or code review thread, and the bot creates a documentation draft linked to the PR context.

You can connect multiple GitHub organizations to a single EkLine organization. Repositories from all connected organizations appear in a combined list on the integrations page. To add another GitHub organization, click **Install on another GitHub organization** in the GitHub App installations section under **Settings > Organization > GitHub Integration**.

**Use cases:**
- Generate a migration guide from the changes in a PR.
- Document a new API endpoint by commenting on the specific code lines.
- Update existing docs based on a feature PR.

<Aside type="tip" title="Create docs without leaving GitHub">
Use the [GitHub PR bot](/agent/github-integration/) to mention `@ekline-ai` in any pull request. The bot reacts, creates a draft in EkLine, and opens a docs PR when ready.
</Aside>

<Aside type="note" title="Organization-level access">
GitHub connects at the organization level. Any EkLine organization member can install the GitHub App on additional GitHub organizations. If a connected GitHub organization becomes inaccessible — for example, if someone uninstalls the app from that organization — a warning appears on the integrations page.
</Aside>

## GitLab

Pull merge requests, issues, and repository files from GitLab into your documentation workflow. Reference GitLab content directly in your prompts to generate or update documentation from your GitLab projects.

**Use cases:**
- Generate a migration guide from changes in a merge request.
- Update documentation based on a completed issue.
- Create technical specs by referencing repository files and merge request discussions.

**Examples:**
```text
Create a changelog entry based on this GitLab merge request:
https://gitlab.com/your-org/platform/-/merge_requests/42
```

```text
Update the authentication docs based on the changes in
GitLab issue #215.
```

```text
Document the new API endpoints by referencing the files
changed in merge request !87.
```

The agent recognizes GitLab URLs automatically — paste a merge request or issue link and the agent fetches the details directly from your connected GitLab instance.

<Aside type="note" title="Organization-level access">
GitLab connects at the organization level. Once a team member authorizes the connection, any organization member can use it through the Docs Agent. The agent accesses content using the permissions of the account that authorized the connection.
</Aside>

## Slack

Turn support conversations, incident threads, and team discussions into structured documentation.

**Use cases:**
- Convert a support answer into a how-to guide.
- Document troubleshooting steps from an incident channel.
- Create FAQ entries from common customer questions.

**Example:**
```text
Create a troubleshooting guide based on this Slack thread:
https://workspace.slack.com/archives/C01234/p1234567890
```

The agent extracts the conversation, identifies the problem, and structures it into documentation format.

<Aside type="tip" title="Create docs without leaving Slack">
Use the [Slack bot](/agent/slack-bot) to @mention `@EkLine` directly in any channel or thread. The bot captures the conversation context and creates a draft you can review in EkLine.
</Aside>

## Notion

Pull product specs, design documents, and meeting notes into your documentation workflow.

**Use cases:**
- Transform product specs into technical documentation.
- Create user guides from design documents.
- Generate API docs from specification pages.

**Example:**
```text
Create API documentation based on the spec in this Notion page:
https://notion.so/your-workspace/api-spec-page-id
```

## Linear

Reference completed work to update documentation or generate release notes.

**Use cases:**
- Update docs when a feature ships.
- Generate release notes from a milestone.
- Create changelog entries from issue descriptions.

**Examples:**
```text
Update the authentication docs based on Linear ticket ENG-1234.
```

```text
Generate release notes for all issues in the v2.0 milestone.
```

The agent reads the issue title, description, and comments to understand what changed.

## Jira

Reference Jira issues the same way you reference Linear tickets.

**Use cases:**
- Update documentation based on completed stories.
- Generate release notes from a sprint or version.
- Create technical specs from epic descriptions.

**Example:**
```text
Update the deployment guide based on Jira ticket PROJ-5678.
Include the new configuration options mentioned in the ticket.
```

## Confluence

Pull existing documentation, runbooks, and internal knowledge into new docs.

**Use cases:**
- Migrate internal docs to your public documentation.
- Create user guides from technical runbooks.
- Reference architecture decisions in new documentation.

**Example:**
```text
Create a public deployment guide based on the internal runbook:
https://your-org.atlassian.net/wiki/spaces/ENG/pages/123456
```

## Google Drive

Connect Google Drive to give the Docs Agent direct access to files and folders in your Drive. Unlike other integrations where you paste a URL, Google Drive lets the agent search, read, create, and organize files on your behalf.

**What the agent can do:**

| Action | Description |
|--------|-------------|
| Search files and folders | Find content by name or keyword |
| Read files | Download and read file contents |
| Create files | Create new documents or text files in Drive |
| Create folders | Organize content into folders |
| Upload files | Upload generated documentation to Drive |
| Move and rename | Reorganize files between folders |
| Delete files | Remove files from Drive |

**Use cases:**
- Pull a PRD from Drive and transform it into technical documentation.
- Save generated documentation directly to a shared Drive folder.
- Search Drive for existing specs before creating new docs.
- Organize generated files into team folders.

**Examples:**
```text
Create a feature overview based on the PRD in my Google Drive
called "Authentication Redesign Spec".
```

```text
Save the generated API reference to the "Engineering Docs"
folder in Google Drive.
```

```text
Search Google Drive for any existing documentation about
the payments API and update it with the latest changes.
```

<Aside type="note" title="Organization-level access">
Google Drive connects at the organization level. Once a team member authorizes the connection, any organization member can use it through the Docs Agent. The agent accesses files using the permissions of the account that authorized the connection.
</Aside>

## PostHog

Connect PostHog to give the Docs Agent access to your product analytics, feature flags, and HogQL queries. The agent can pull insights from PostHog during documentation sessions to ground your content in real usage data.

**What the agent can do:**

| Action | Description |
|--------|-------------|
| Query insights | Read saved insights and analytics dashboards |
| Run HogQL queries | Execute HogQL queries against your PostHog data |
| Read feature flags | List and inspect feature flag configurations |

**Use cases:**
- Reference adoption metrics when writing release notes or feature documentation.
- Include feature flag details when documenting rollout procedures.
- Pull usage data to support decisions in architecture or migration guides.

**Examples:**
```text
Summarize the adoption metrics for the new onboarding flow
using the PostHog insights dashboard.
```

```text
Document the current feature flag configuration for
the "new-checkout" rollout, including rollout percentage
and targeting rules.
```

```text
Create a usage report based on the HogQL query for
weekly active users over the last 90 days.
```

### Connect PostHog

<Steps>
1. Go to **Settings > Organization > Integrations** in your EkLine dashboard.
2. Click **Connect** on the PostHog card.
3. Enter your PostHog personal API key. You can generate one from **PostHog > Settings > Personal API Keys**.
4. Select your PostHog region (US, EU, or enter a custom hostname for self-hosted instances).
5. Click **Connect** to activate the integration.
</Steps>

The personal API key starts with `phx_`.

<Aside type="note" title="Supported regions">
PostHog offers four cloud regions — **US (Public)**, **US (Private)**, **EU (Public)**, and **EU (Private)**. If you run a self-hosted PostHog instance, select **Custom** and enter your hostname.
</Aside>

<Aside type="note" title="Organization-level access">
PostHog connects at the organization level. Once a team member connects PostHog, any organization member can use it through the Docs Agent. The agent accesses data using the permissions of the personal API key that the connecting team member provided.
</Aside>

## Combine multiple sources

Reference multiple integrations in a single prompt to create comprehensive documentation.

```text
Update the authentication docs based on:
- Linear ticket ENG-1234 (the feature implementation)
- This Slack thread where we discussed edge cases:
  https://workspace.slack.com/archives/C01234/p1234567890
- The original spec in Notion:
  https://notion.so/your-workspace/auth-spec
```

## Tips

<Aside type="tip" title="Best practices">
- **Reference exact URLs or IDs** — Paste a URL from a connected integration, and the agent automatically recognizes the service and fetches the content.
- **Verify access** — You can only pull content you have permission to view.
- **Add context** — Tell the agent what kind of documentation you need from the source.
- **Combine thoughtfully** — Multiple sources work best when they relate to the same topic.
</Aside>