LinkedIn MCP Server

https://github.com/stickerdaniel/linkedin-mcp-server
Admin
A Dockerized server that allows AI assistants like Claude to connect to LinkedIn, enabling access to...
Tokens:154,648
Snippets:1,048
Trust Score:8.6
License:Apache-2.0
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### start_background_browser_setup_if_needed

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/bootstrap.md

Asynchronous function to start the background browser setup task if needed.

```APIDOC
## start_background_browser_setup_if_needed

### Description
Starts the background browser-setup task for non-OWNER lifespans.

### Signature
```python
async def start_background_browser_setup_if_needed() -> None:
```
```

--------------------------------

### Example usage of session_state functions

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/session_state.md

Example showing how to get the source profile directory, load source state, and print login generation and identity.

```python
from pathlib import Path
from linkedin_mcp_server.session_state import (
    get_source_profile_dir, load_source_state, auth_state_identity,
)

profile = get_source_profile_dir()
state = load_source_state(profile)
if state is not None:
    print("login generation:", state.login_generation)
print("identity:", auth_state_identity(profile))
```

--------------------------------

### Install and run LinkedIn MCP server from source

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/README.md

Install and run the LinkedIn MCP server from source. Requires Git and uv. Clones the repository, installs uv if needed, syncs dependencies (including dev group), installs pre-commit hooks, and starts the server.

```bash
# 1. Clone repository
git clone https://github.com/stickerdaniel/linkedin-mcp-server
cd linkedin-mcp-server

# 2. Install UV package manager (if not already installed)
curl -LsSf https://astral.sh/uv/install.sh | sh

# 3. Install dependencies
uv sync
uv sync --group dev

# 4. Install pre-commit hooks
uv run pre-commit install

# 5. Start the server
uv run -m linkedin_mcp_server

```

--------------------------------

### Install uv

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/README.md

Installs uv, required for running the server. Check version with uv --version (should be 0.4.0 or higher).

```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```

--------------------------------

### Usage example for refresh_latest_version and pending_update_notice

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/update_check.md

Usage example showing explicit refresh and printing the update notice if available. The refresh is rejection-safe in the background.

```python
import asyncio

async def main() -> None:
    await refresh_latest_version()          # explicit refresh (background rejection-safe)
    notice = pending_update_notice()
    if notice is not None:
        print(notice)                       # "A newer version ... is available ..."

asyncio.run(main())

```

--------------------------------

### Start server and test MCP tool with curl

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/AGENTS.md

Use this sequence to start the MCP server and manually test a tool call over streamable HTTP. The initialize request returns a Mcp-Session-Id header that must be captured and reused for subsequent tool calls; the example calls get_person_profile with linkedin_username "williamhgates" and sections "posts".

```bash
# Start server
uv run -m linkedin_mcp_server --transport streamable-http --log-level DEBUG

# Initialize MCP session (grab Mcp-Session-Id from response headers)
curl -s -D /tmp/mcp-headers -X POST http://127.0.0.1:8000/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-03-26","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}}}'

# Extract the session ID from saved headers
SESSION_ID=$(grep -i 'Mcp-Session-Id' /tmp/mcp-headers | awk '{print $2}' | tr -d '\r')

# Call a tool
curl -s -X POST http://127.0.0.1:8000/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "Mcp-Session-Id: $SESSION_ID" \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"get_person_profile","arguments":{"linkedin_username":"williamhgates","sections":"posts"}}}'
```

--------------------------------

### browser_setup_ready

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/bootstrap.md

Synchronous check for whether browser setup has completed successfully.

```APIDOC
## browser_setup_ready

### Description
Setup outcome flag indicating whether browser setup has completed successfully.

### Signature
```python
def browser_setup_ready() -> bool:
```

### Returns
- **bool** - True if browser setup is ready.
```

--------------------------------

### Using LoginViewer to start and stop the viewer

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/login_viewer.md

Example usage of LoginViewer: starts the window manager, starts remote control to get the viewer URL, and cleans up in a finally block. The URL is printed and can be used to access the noVNC page.

```python
from linkedin_mcp_server.login_viewer import LoginViewer, LoginViewerError, viewer_url

viewer = LoginViewer(display=":99")
try:
    viewer.start_window_manager()
    url = viewer.start_remote_control()
    print(viewer_url_token := url)     # http://127.0.0.1:6080/vnc_lite.html#?path=...
    ...
finally:
    viewer.stop_remote_control()
    viewer.stop_window_manager()
```

--------------------------------

### Start MCP server (cli_main.main)

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/endpoints.md

Shows how the MCP server is started in cli_main.main(). Creates the server with a configurable tool timeout, then runs it with the streamable-http transport (with host_origin_protection enabled) or falls back to the default transport. When a daemon owner is elected, the process becomes a PROXY and forwards tool calls over loopback instead of registering local tools.

```python
mcp = create_mcp_server(tool_timeout=config.server.tool_timeout_seconds)
if transport == "streamable-http":
    mcp.run(
        transport=transport,
        host=config.server.host,
        port=config.server.port,
        path=config.server.path,
        host_origin_protection=True,
    )
else:
    mcp.run(transport=transport)
```

--------------------------------

### browser_ready

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/bootstrap.md

Synchronous check for browser readiness based on install metadata.

```APIDOC
## browser_ready

### Description
Whether the installed browser revision is ready for launch (checks install metadata).

### Signature
```python
def browser_ready() -> bool:
```

### Returns
- **bool** - True if the browser revision is ready for launch.
```

--------------------------------

### Usage example for look_up_owner

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/daemon.md

Usage example showing how to call look_up_owner with the source profile directory and configuration, then handle ATTACHABLE and INCOMPATIBLE states.

```python
from pathlib import Path
from linkedin_mcp_server.daemon import OwnerState, look_up_owner
from linkedin_mcp_server.session_state import auth_root_dir, get_source_profile_dir
from linkedin_mcp_server.config import get_config

profile = get_source_profile_dir()
lookup = look_up_owner(auth_root_dir(profile), profile, get_config())
if lookup.state is OwnerState.ATTACHABLE and lookup.attachment is not None:
    print("owner at", lookup.attachment.descriptor.url)
elif lookup.state is OwnerState.INCOMPATIBLE:
    print("incompatible:", lookup.mismatch)

```

--------------------------------

### Install and run MCP inspector

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/README.md

Installs and runs the MCP inspector. After running, click the pre-filled token URL, select Streamable HTTP as Transport Type, set URL to http://localhost:8080/mcp, connect, and test tools.

```bash
bunx @modelcontextprotocol/inspector
```

--------------------------------

### browser_setup_in_progress

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/bootstrap.md

Synchronous check for whether background browser setup is in progress.

```APIDOC
## browser_setup_in_progress

### Description
Whether background setup is currently running.

### Signature
```python
def browser_setup_in_progress() -> bool:
```

### Returns
- **bool** - True if background setup is currently running.
```

--------------------------------

### Configure mcp-server-linkedin with uvx in mcpServers

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/README.md

Add this configuration to your MCP client's mcpServers to run the server via uvx. The @latest tag enables automatic updates, which keep the server working with LinkedIn's current page structure. The server starts quickly and prepares the shared Patchright Chromium browser cache in the background under ~/.linkedin-mcp/patchright-browsers. On the first tool call that needs authentication, it reuses a LinkedIn session from a signed-in local browser if it finds one, and otherwise opens a LinkedIn login browser window. AI agents should get a quick confirmation from the user before enabling automatic updates. Early tool calls may return a setup/authentication-in-progress error until browser setup or login finishes.

```json
{
  "mcpServers": {
    "mcp-server-linkedin": {
      "command": "uvx",
      "args": ["mcp-server-linkedin@latest"],
      "env": { "UV_HTTP_TIMEOUT": "300" }
    }
  }
}
```

--------------------------------

### BrowserManager async context manager usage

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/core.md

Example of using BrowserManager as an async context manager. Starts the browser, navigates to LinkedIn feed, prints authentication status, and exports cookies.

```python
from linkedin_mcp_server.core import BrowserManager

async def example() -> None:
    async with BrowserManager(headless=True) as browser:
        await browser.start()
        page = browser.page
        await page.goto("https://www.linkedin.com/feed/")
        print(browser.is_authenticated)
        await browser.export_cookies()
```

--------------------------------

### Create and serve owner server with create_owner_server

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/daemon_owner.md

Example of creating and serving the owner server. Port 0 lets the election bind and publish the actual port. The stand_down callback prints a message when the stand-down route is invoked.

```python
from linkedin_mcp_server.daemon_owner import create_owner_server, MCP_PATH

server = create_owner_server(
    config=config,
    token=token,
    host="127.0.0.1",
    port=0,                       # election binds and publishes the port
    stand_down=lambda: print("standing down"),
)
await server.serve()
```

--------------------------------

### Example stackwalk output for #838

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/docs/windows-crash-dumps.md

Example output from minidump-stackwalk for issue #838, showing a crash in _wmi.pyd with an instruction and register values. Completion criteria require naming a module and an instruction, not just addresses.

```text
EXCEPTION_ACCESS_VIOLATION_READ
Thread 7 (crashed)  _wmi.pyd + 0x1650
  mov rcx, qword [rsi + 0x8]    rsi = 0x0000002b20dbb878
```

--------------------------------

### create_mcp_server usage examples

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/server.md

Usage examples for create_mcp_server. Shows the basic direct server with stdio transport, a daemon owner endpoint with token authentication and HTTP transport, and a ValueError raised when a token is used with a non-owner role. The error message is "Only a daemon owner authenticates requests, not direct".

```python
# Basic usage — the historical direct server:
mcp = create_mcp_server(tool_timeout=180.0)
mcp.run(transport="stdio")

# Daemon owner endpoint (loopback HTTP, token-authenticated):
mcp = create_mcp_server(
    tool_timeout=config.server.tool_timeout_seconds,
    role=ServerRole.OWNER,
    auth_token=token,
)
# ... then mcp.http_app(path="/mcp", transport="http", host_origin_protection=True, allowed_hosts=[...])

# Attempting a token on a non-owner role:
try:
    create_mcp_server(role=ServerRole.DIRECT, auth_token="secret")
except ValueError as e:
    print(e)  # "Only a daemon owner authenticates requests, not direct"
```

--------------------------------

### Config singleton function signatures

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/config.md

Shows the declared signatures of the three config singleton functions. get_config lazily loads configuration from environment and defaults (no argv), set_config installs a prebuilt AppConfig before any reads, and reset_config forgets the installed config.

```python
def get_config() -> AppConfig:
def set_config(config: AppConfig) -> None:
def reset_config() -> None:

```

--------------------------------

### Usage example with MCPContextProgressCallback and custom LoggingCallback

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/callbacks.md

Usage example showing how to pass an MCPContextProgressCallback to read_person and a custom LoggingCallback to get_my_profile. The custom callback prints progress messages with a percentage prefix.

```python
from fastmcp import Context
from linkedin_mcp_server.callbacks import MCPContextProgressCallback

async def tool(ctx: Context) -> dict:
    extractor = ...  # authenticated LinkedInExtractor
    cb = MCPContextProgressCallback(ctx)          # forwards into the MCP session
    return await extractor.read_person(
        "stickerdaniel", {"experience", "education"}, callbacks=cb
    )
```

```python
# A custom callback for embedded use:
from linkedin_mcp_server.callbacks import ProgressCallback

class LoggingCallback(ProgressCallback):
    async def on_progress(self, message: str, percent: int) -> None:
        print(f"[{percent}%] {message}")

result = await extractor.get_my_profile(
    sections={"posts"}, callbacks=LoggingCallback(), max_scrolls=8
)
```

--------------------------------

### ensure_tool_ready_or_raise

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/bootstrap.md

Asynchronous readiness gate for tools, raising errors when setup or authentication is not ready.

```APIDOC
## ensure_tool_ready_or_raise

### Description
Gate read/search tools on browser setup and authentication readiness. Called at the top of every tool body (through `get_ready_extractor`). Initializes bootstrap, refreshes background-task state, surfaces a previous setup failure, and for an `OWNER` role refuses when a stand-down is pending.

### Signature
```python
async def ensure_tool_ready_or_raise(
    tool_name: str, ctx: Context | None = None
) -> None:
```

### Parameters
- **tool_name** (str) - Required - The name of the tool being gated.
- **ctx** (Context | None) - Optional - The execution context.

### Raises
- `BrowserSetupFailedError` - Previous setup failed.
- `OwnerStandingDownError` - Owner restarting.
- `AuthenticationStartedError` - Auth gates.
- `AuthenticationInProgressError` - Auth gates.
- `CredentialsNotFoundError` - Auth gates.
- `AuthStaleOnOwnerError` - Auth gates.
- `BrowserBusyError` - Profile held.
```

--------------------------------

### build_references usage example

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/link_metadata.md

Example usage of build_references with a raw list of dictionaries, showing how to construct references and print their kind, URL, text, and context. The output comment shows the expected kinds: person, external, and job.

```python
from linkedin_mcp_server.linkedin.link_metadata import build_references

raw = [
    {"href": "/in/stickerdaniel/", "text": "Daniel Sticker", "heading": "Top card"},
    {"href": "/redir/redirect/?url=https%3A%2F%2Fexample.com", "text": "Example"},
    {"href": "/in/stickerdaniel/", "aria_label": "View: Stickerdaniel's profile"},
    {"href": "/jobs/view/4252026496/"},
    {"href": "javascript:void(0)", "text": "drop me"},
]
refs = build_references(raw, section_name="main_profile")
for ref in refs:
    print(ref["kind"], ref["url"], ref.get("text"), ref.get("context"))
# person /in/stickerdaniel/ ... ; external https://example.com ; job /jobs/view/4252026496/
```

--------------------------------

### Install Codex plugin for LinkedIn MCP server

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/README.md

Install the LinkedIn MCP server as a Codex plugin. The plugin pins a server release, and Codex picks up each new one in the background when it starts. On the first tool call that needs authentication, the server reuses a LinkedIn session from a signed-in local browser or opens a login window.

```bash
codex plugin marketplace add stickerdaniel/linkedin-mcp-server
codex plugin add linkedin-mcp-server@linkedin-mcp-server
```

--------------------------------

### Retrieve and set config singleton

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/config.md

Shows importing the config functions, retrieving the lazy-loaded config to print transport and headless, and installing a custom AppConfig after setting transport and host and calling validate().

```python
from linkedin_mcp_server.config import get_config, set_config
from linkedin_mcp_server.config.schema import AppConfig

config = get_config()
print(config.server.transport, config.browser.headless)

# Embedder installing its own validated config:
mine = AppConfig()
mine.server.transport = "streamable-http"
mine.server.host = "0.0.0.0"
mine.validate()
set_config(mine)

```

--------------------------------

### pending_update_notice function signature

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/update_check.md

Returns the one-line notice when the installed version is behind, else None. Uses _is_meaningfully_behind and _update_action to phrase install instructions per runtime kind.

```python
def pending_update_notice() -> str | None:

```

--------------------------------

### Usage example: tool body pattern

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/dependencies.md

Example showing the pattern every tool body follows: acquire an extractor, handle authentication errors, and raise other errors. It imports from dependencies, core.exceptions, and error_handler.

```python
from fastmcp import Context
from linkedin_mcp_server.dependencies import get_ready_extractor, handle_auth_error
from linkedin_mcp_server.core.exceptions import AuthenticationError
from linkedin_mcp_server.error_handler import raise_tool_error

async def my_tool(linkedin_username: str, ctx: Context) -> dict:
    try:
        extractor = await get_ready_extractor(ctx, tool_name="my_tool")
        return await extractor.read_person(linkedin_username, {"main_profile"})
    except AuthenticationError as e:
        # Nothing has run yet: the client may safely replay once signed in.
        await handle_auth_error(e, ctx, nothing_ran_yet=True)
    except Exception as e:
        raise_tool_error(e, "my_tool")
```

--------------------------------

### Usage example for server role functions

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/server_role.md

Shows how to query and set the process role, and the error raised when attempting to claim a second, different role. The output demonstrates the default DIRECT role and the RoleAlreadyClaimedError message.

```python
from linkedin_mcp_server.server_role import (
    ServerRole, process_role, set_process_role, RoleAlreadyClaimedError,
)

print(process_role())          # ServerRole.DIRECT (unclaimed default)
set_process_role(ServerRole.OWNER)
print(process_role())          # ServerRole.OWNER
try:
    set_process_role(ServerRole.PROXY)   # second, different role
except RoleAlreadyClaimedError as e:
    print(e)  # "This process already serves as owner, so it cannot also serve as proxy"
```

--------------------------------

### Usage example for obtain_owner

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/daemon_election.md

Usage example showing how to call obtain_owner with the standard production arguments. It prints the loopback HTTP URL when an attachment is worth connecting to, or the state and fallback when no owner is available.

```python
from linkedin_mcp_server.daemon_election import obtain_owner
from linkedin_mcp_server.session_state import auth_root_dir, get_source_profile_dir
from linkedin_mcp_server.config import get_config

outcome = obtain_owner(
    auth_root_dir(get_source_profile_dir()),
    get_source_profile_dir(),
    get_config(),
)
if outcome.worth_connecting:
    attachment = outcome.attachment_lookup.attachment
    assert attachment is not None
    print("forward to", attachment.descriptor.url)   # loopback HTTP
else:
    print("no owner; drive your own browser",
          outcome.attachment_lookup.state, outcome.attachment_lookup.fallback)
```

--------------------------------

### Install symbolisation tools on macOS

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/docs/windows-crash-dumps.md

Installs the tools needed to symbolise Windows crash dumps on macOS: msitools and sevenzip via Homebrew, and dump_syms and minidump-stackwalk via Cargo (installed to ~/.cargo/bin).

```bash
brew install msitools sevenzip
cargo install dump_syms minidump-stackwalk   # lands in ~/.cargo/bin
```

--------------------------------

### Using get_or_create_browser and close_browser

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/drivers_browser.md

Example usage of get_or_create_browser and close_browser. Imports the necessary functions and handles AuthenticationError. The finally block ensures the browser is closed.

```python
from linkedin_mcp_server.drivers.browser import get_or_create_browser, close_browser
from linkedin_mcp_server.core import AuthenticationError

try:
    browser = await get_or_create_browser()
    print(browser.is_authenticated)
except AuthenticationError as e:
    print("Session expired or invalid:", e)
finally:
    await close_browser()
```

--------------------------------

### browser_setup_failure_pending

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/bootstrap.md

Synchronous check for whether a browser setup failure is pending.

```APIDOC
## browser_setup_failure_pending

### Description
Setup outcome flag indicating whether a previous setup failure is pending.

### Signature
```python
def browser_setup_failure_pending() -> bool:
```

### Returns
- **bool** - True if a setup failure is pending.
```

--------------------------------

### ensure_browser_installed

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/bootstrap.md

Synchronous blocking function to ensure the browser is installed.

```APIDOC
## ensure_browser_installed

### Description
Synchronous, blocking browser install used by CLI modes (`--login`, `--status`, `--import-from-browser`).

### Signature
```python
def ensure_browser_installed() -> None:
```
```

--------------------------------

### Acquire and release profile lease

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/profile_lease.md

Usage example for acquiring and releasing the profile lease. The first part shows the owner side using try_acquire, marking the browser open/closed, and releasing in a finally block. The second part shows the waiter side using await lease.acquire with a 25-second timeout.

```python
from linkedin_mcp_server.profile_lease import get_profile_lease

lease = get_profile_lease()
if lease.try_acquire():
    try:
        lease.mark_browser_open()
        ...  # drive Chromium on the shared profile
    finally:
        lease.mark_browser_closed()
        lease.release()

# Waiter side — bounded:
if await lease.acquire(timeout=25.0):
    ...  # got the browser handover
```

--------------------------------

### set_config(config)

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/config.md

Installs a prebuilt `AppConfig`; used by the detached daemon owner, which is handed its settings rather than parsing them. Must be called before anything reads configuration.

```APIDOC
## set_config(config: AppConfig) -> None

### Description
Installs a prebuilt `AppConfig`; used by the detached daemon owner, which is handed its settings rather than parsing them. Must be called before anything reads configuration.

### Method
Function

### Signature
`def set_config(config: AppConfig) -> None`

### Parameters
- **config** (AppConfig) - Required - The prebuilt configuration to install.

### Example
```python
from linkedin_mcp_server.config import set_config
from linkedin_mcp_server.config.schema import AppConfig

mine = AppConfig()
mine.server.transport = "streamable-http"
mine.server.host = "0.0.0.0"
mine.validate()
set_config(mine)
```
```

--------------------------------

### Usage example: role-dependent middleware wiring

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/daemon_auth.md

Shows how create_mcp_server instantiates the middleware based on server role. Direct servers never instantiate these classes.

```python
# server.py (role-dependent wiring, abbreviated)
if role is ServerRole.OWNER:
    mcp.add_middleware(OwnerAuthSignalMiddleware())
if role is ServerRole.PROXY:
    mcp.add_middleware(FrontendAuthRepairMiddleware(tool_timeout=tool_timeout))

```

--------------------------------

### Usage example for linkedin_mcp_server.bootstrap

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/bootstrap.md

Shows how to use the bootstrap module inside a tool body: retrieve the runtime policy, inspect the bootstrap state, and call ensure_tool_ready_or_raise before opening the browser. The comment notes that after this call it is safe to open the browser.

```python
from fastmcp import Context
from linkedin_mcp_server.bootstrap import (
    get_runtime_policy, get_bootstrap_state, ensure_tool_ready_or_raise,
)

def tool_body(ctx: Context) -> None:
    print(get_runtime_policy())        # RuntimePolicy.MANAGED | DOCKER
    print(get_bootstrap_state().setup_state)
    await ensure_tool_ready_or_raise("get_person_profile", ctx)
    # ... now safe to open the browser
```

--------------------------------

### stop_background_browser_setup

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/bootstrap.md

Asynchronous function to stop the background browser setup task.

```APIDOC
## stop_background_browser_setup

### Description
Cancels and joins the setup task.

### Signature
```python
async def stop_background_browser_setup() -> None:
```
```

--------------------------------

### reset_config()

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/config.md

Forgets the installed config so the next `get_config()` reloads.

```APIDOC
## reset_config() -> None

### Description
Forgets the installed config so the next `get_config()` reloads.

### Method
Function

### Signature
`def reset_config() -> None`
```

--------------------------------

### Run server in HTTP mode (streamable-http)

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/README.md

Starts the server in HTTP mode for web-based MCP clients. Listens on 127.0.0.1:8080 at /mcp. Runtime logs are emitted by FastMCP/Uvicorn.

```bash
uvx mcp-server-linkedin@latest --transport streamable-http --host 127.0.0.1 --port 8080 --path /mcp
```

--------------------------------

### Usage example for get_ready_extractor and read_person

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/extractor.md

Shows how to obtain a ready extractor via get_ready_extractor, parse section names with parse_person_sections, and call read_person. Handles AuthenticationError (session expired) and RateLimitError (suggested wait time) and prints the result URL and section keys.

```python
import asyncio
from linkedin_mcp_server.dependencies import get_ready_extractor
from linkedin_mcp_server.linkedin import parse_person_sections
from linkedin_mcp_server.core import AuthenticationError, RateLimitError

async def main() -> None:
    extractor = await get_ready_extractor(None, tool_name="get_person_profile")
    sections, unknown = parse_person_sections("experience,education")
    try:
        result = await extractor.read_person("stickerdaniel", sections)
    except AuthenticationError:
        print("Session expired — run with --login")
    except RateLimitError as e:
        print(f"Rate limited, wait {e.suggested_wait_time}s")
    print(result["url"], list(result["sections"]))

asyncio.run(main())
```

--------------------------------

### Custom timeouts (Windows)

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/docs/docker-hub.md

Example MCP client configuration for Windows that sets custom TIMEOUT and TOOL_TIMEOUT environment variables for the Docker container.

```json
{
  "mcpServers": {
    "mcp-server-linkedin": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-v", "C:/Users/Alice/.linkedin-mcp:/home/pwuser/.linkedin-mcp",
        "-e", "TIMEOUT=10000",
        "-e", "TOOL_TIMEOUT=300",
        "stickerdaniel/linkedin-mcp-server"
      ]
    }
  }
}
```

--------------------------------

### LoginViewer class and constructor

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/login_viewer.md

Class definition and constructor signature for LoginViewer. The display parameter defaults to None, using the container's display setup.

```python
class LoginViewer:
    """Supervise Openbox and the two remote-control exposure layers."""

    def __init__(self, *, display: str | None = None) -> None:
```

--------------------------------

### Run server in HTTP mode with streamable-http transport

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/README.md

Start the server in HTTP mode for web-based MCP clients. Forces the streamable-http transport and binds to 127.0.0.1:8000 with the /mcp path.

```bash
uv run -m linkedin_mcp_server --transport streamable-http --host 127.0.0.1 --port 8000 --path /mcp

```

--------------------------------

### get_authentication_source

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/session_state.md

Returns True when the source profile + portable cookies + source state all exist, else raises `CredentialsNotFoundError` with setup guidance.

```APIDOC
## get_authentication_source

### Description
Returns True when the source profile + portable cookies + source state all exist, else raises `CredentialsNotFoundError` with setup guidance.

### Method
Function

### Signature
`get_authentication_source() -> bool`

### Returns
- **bool** - True if the source profile, portable cookies, and source state all exist.

### Raises
- **CredentialsNotFoundError** - If any of the required components are missing.

### Example
```python
from linkedin_mcp_server.authentication import get_authentication_source
if get_authentication_source():
    print("Authentication source available")
```
```

--------------------------------

### Custom timeouts (macOS/Linux)

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/docs/docker-hub.md

Example MCP client configuration for macOS/Linux that sets custom TIMEOUT and TOOL_TIMEOUT environment variables for the Docker container.

```json
{
  "mcpServers": {
    "mcp-server-linkedin": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-v", "/absolute/path/to/.linkedin-mcp:/home/pwuser/.linkedin-mcp",
        "-e", "TIMEOUT=10000",
        "-e", "TOOL_TIMEOUT=300",
        "stickerdaniel/linkedin-mcp-server"
      ]
    }
  }
}
```

--------------------------------

### Windows event log faulting module line

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/docs/windows-crash-dumps.md

Example line from the Windows event log, printed by the 'Report what the dump folder holds' step, used to cross-check the crash module and version.

```text
Faulting module name: _wmi.pyd, version: 3.12.10150.1013
```

--------------------------------

### Internal helper function signatures

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/update_check.md

Internal helper functions for update checking. _check_disabled returns True when LINKEDIN_MCP_CHECK_FOR_UPDATES is falsy, a CI env marker is present, or the install is from source. _read_cache returns (timestamp, latest) from ~/.linkedin-mcp cache, fresh within 24h. _fetch_latest_from_pypi performs one JSON GET of PyPI metadata, returning None on any failure.

```python
def _is_source_install() -> bool:
def _check_disabled() -> bool:            # LINKEDIN_MCP_CHECK_FOR_UPDATES off/false, CI env, source installs
def _read_cache() -> tuple[float, str] | None:
def _write_cache(latest: str) -> None:
def _fetch_latest_from_pypi() -> str | None:
def _fresh_cached_latest() -> str | None:
def _is_meaningfully_behind(current: Version, latest: Version) -> bool:
def _runtime_kind() -> str:
def _update_action() -> str:

```

--------------------------------

### Create DaemonProxyBackend and proxy provider

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/daemon_proxy.md

Instantiates DaemonProxyBackend with attachment, auth_root, profile, and config, then adds a proxy provider with a 180-second tool timeout and sets the provider error strategy to 'raise'.

```python
from linkedin_mcp_server.daemon_proxy import (
    DaemonProxyBackend, create_proxy_provider,
)
from linkedin_mcp_server.daemon import Attachment
from linkedin_mcp_server.server_role import ServerRole

backend = DaemonProxyBackend(
    attachment=attachment, auth_root=auth_root, profile=profile, config=config,
)
mcp.add_provider(create_proxy_provider(backend, tool_timeout=180.0))
mcp.provider_error_strategy = "raise"
```

--------------------------------

### Run one-shot login container with --login --login-viewer

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/docs/docker-hub.md

One-shot login container that publishes a viewer on port 6080. Create the host directory first so the session can be saved; the command prints a URL with an access token to open in your browser. The viewer closes itself and the command exits on its own after storing the session; it gives up after 30 minutes.

```bash
mkdir -p ~/.linkedin-mcp
docker run -it --rm \
  -v ~/.linkedin-mcp:/home/pwuser/.linkedin-mcp \
  -p 127.0.0.1:6080:6080 \
  stickerdaniel/linkedin-mcp-server:latest \
  --login --login-viewer
```

```powershell
$sessionDir = Join-Path $env:USERPROFILE ".linkedin-mcp"
New-Item -ItemType Directory -Force -Path $sessionDir | Out-Null
docker run -it --rm `
  -v "${sessionDir}:/home/pwuser/.linkedin-mcp" `
  -p 127.0.0.1:6080:6080 `
  stickerdaniel/linkedin-mcp-server:latest `
  --login --login-viewer
```

--------------------------------

### Example usage of normalize_person_identifier and InvalidReferenceError

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/identifiers.md

Example usage of `normalize_person_identifier`. It handles a bare identifier and full profile URLs (including locale and query), returning the bare identifier. A shortened `lnkd.in` link raises `InvalidReferenceError` because only a redirect resolves it.

```python
from linkedin_mcp_server.linkedin.identifiers import normalize_person_identifier
from linkedin_mcp_server.core.exceptions import InvalidReferenceError

for raw in ("stickerdaniel", "https://www.linkedin.com/in/stickerdaniel/",
            "https://de.linkedin.com/in/stickerdaniel?trk=share"):
    print(normalize_person_identifier(raw))  # -> stickerdaniel

try:
    normalize_person_identifier("https://lnkd.in/xyz")
except InvalidReferenceError as e:
    print(e)  # "That is a shortened LinkedIn link, and only a redirect resolves it..."
```

--------------------------------

### load_from_args(config, argv)

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/config.md

Applies the CLI flags (table in configuration.md); `--user-agent` raises the same refusal; `--proxy-server` refuses embedded credentials (`credential_free_url`).

```APIDOC
## load_from_args(config: AppConfig, argv: Sequence[str]) -> AppConfig

### Description
Applies the CLI flags (table in configuration.md); `--user-agent` raises the same refusal; `--proxy-server` refuses embedded credentials (`credential_free_url`).

### Method
Function

### Signature
`def load_from_args(config: AppConfig, argv: Sequence[str]) -> AppConfig`

### Parameters
- **config** (AppConfig) - Required - The configuration object to populate.
- **argv** (Sequence[str]) - Required - CLI arguments.

### Raises
- **ConfigurationError** - If `--user-agent` is provided or `--proxy-server` contains embedded credentials.
```

--------------------------------

### LinkedInExtractor.__init__

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/extractor.md

Initializes a new LinkedInExtractor instance with an authenticated browser page.

```APIDOC
## Constructor

### Description
Initializes a new LinkedInExtractor instance with an authenticated browser page.

### Parameters
- **page** (patchright.async_api.Page) - Required - The authenticated browser page to drive

### Example
```python
from linkedin_mcp_server.linkedin import LinkedInExtractor

extractor = LinkedInExtractor(page)
```
```

--------------------------------

### load_config(argv)

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/config.md

Loads configuration from defaults, environment, and optionally CLI arguments. Precedence: defaults → `.env`/environment → CLI args → `config.validate()`. Raises `ConfigurationError` on validation failure.

```APIDOC
## load_config(argv: Sequence[str] | None = None) -> AppConfig

### Description
Loads configuration from defaults, environment, and optionally CLI arguments. Precedence: defaults → `.env`/environment → CLI args → `config.validate()`. Raises `ConfigurationError` on validation failure.

### Method
Function

### Signature
`def load_config(argv: Sequence[str] | None = None) -> AppConfig`

### Parameters
- **argv** (Sequence[str] | None) - Optional - Default: `None` - CLI arguments. When omitted, only defaults and environment are loaded; when given, CLI wins over environment.

### Raises
- **ConfigurationError** - On validation failure.

### Example
```python
from linkedin_mcp_server.config.loaders import load_config

config = load_config()
```
```

--------------------------------

### dedupe_references

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/link_metadata.md

Documentation for the `dedupe_references` function, including its signature, parameters, return type, and a usage example.

```APIDOC
## `dedupe_references`

### Description
Deduplicates a list of `Reference` objects by URL, keeping the cleaner, richer duplicate in first-seen order. Optionally truncates the result to a maximum number of references when `cap` is provided.

### Signature
```python
def dedupe_references(
    references: list[Reference],
    cap: int | None = None,
) -> list[Reference]:
```

### Parameters
- **references** (list[Reference]) - Required - The list of reference objects to deduplicate.
- **cap** (int | None) - Optional - Maximum number of references to return. If `None`, no truncation is applied.

### Returns
- **list[Reference]** - The deduplicated list of references, in first-seen order, truncated to `cap` if provided.

### Example
```python
from linkedin_mcp_server.linkedin.link_metadata import build_references

raw = [
    {"href": "/in/stickerdaniel/", "text": "Daniel Sticker", "heading": "Top card"},
    {"href": "/redir/redirect/?url=https%3A%2F%2Fexample.com", "text": "Example"},
    {"href": "/in/stickerdaniel/", "aria_label": "View: Stickerdaniel's profile"},
    {"href": "/jobs/view/4252026496/"},
    {"href": "javascript:void(0)", "text": "drop me"},
]
refs = build_references(raw, section_name="main_profile")
for ref in refs:
    print(ref["kind"], ref["url"], ref.get("text"), ref.get("context"))
# person /in/stickerdaniel/ ... ; external https://example.com ; job /jobs/view/4252026496/
```
```

--------------------------------

### invalidate_browser_setup

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/bootstrap.md

Synchronous function to invalidate browser setup metadata, forcing a retry on next call.

```APIDOC
## invalidate_browser_setup

### Description
Marks install metadata invalid so the next call retries setup (used when the binary turns out missing).

### Signature
```python
def invalidate_browser_setup() -> None:
```
```

--------------------------------

### Load from environment, args, and interactive check signatures

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/config.md

Signatures of the environment and CLI loaders and the TTY checker. load_from_env rejects invalid TRANSPORT, TIMEOUT, TOOL_TIMEOUT, LOGIN_TIMEOUT, LOGIN_INLINE_WAIT, BROWSER_*, PORT, SLOW_MO, and VIEWPORT values; setting USER_AGENT raises ConfigurationError. load_from_args applies CLI flags, refuses --user-agentestrategies, and refuses proxy credentials in --proxy-server. is_interactive_environment returns true when both stdin and stdout are TTYs.

```python
def load_from_env(config: AppConfig) -> AppConfig:
def load_from_args(config: AppConfig, argv: Sequence[str]) -> AppConfig:
def is_interactive_environment() -> bool:

```

--------------------------------

### get_config()

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/config.md

Returns the process configuration, lazily loading `load_config()` (environment + defaults, no argv) the first time.

```APIDOC
## get_config()

### Description
Returns the process configuration, lazily loading `load_config()` (environment + defaults, no argv) the first time.

### Method
Function

### Signature
`def get_config() -> AppConfig`

### Returns
- **AppConfig** - The process configuration.

### Example
```python
from linkedin_mcp_server.config import get_config

config = get_config()
print(config.server.transport, config.browser.headless)
```
```

--------------------------------

### Run server with debug logging (--log-level DEBUG)

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/README.md

Runs the server with debug logging to see wait/acquire/release logs for the shared browser session. Useful when multiple MCP clients contend for the browser.

```bash
uvx mcp-server-linkedin@latest --log-level DEBUG
```

--------------------------------

### get_ready_extractor function signature

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/dependencies.md

Signature for the async function that returns an authenticated LinkedInExtractor. It takes a FastMCP context and tool name, and raises various errors if setup or authentication fails.

```python
async def get_ready_extractor(
    ctx: Context | None,
    *,
    tool_name: str,
) -> LinkedInExtractor:
```

--------------------------------

### Auth State Helpers and Policy/Path Functions

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/bootstrap.md

Python helper functions for auth state management and runtime policy/path configuration.

```APIDOC
## current_login_generation()

### Description
Returns the current `login_generation` value on disk, or `None` if there is none.

### Method
Function

### Signature
`current_login_generation() -> str | None`

### Parameters
None

### Returns
- **str | None** - The current login generation, or `None` if none exists.
```

```APIDOC
## go_auth_quiescent(observed_generation)

### Description
Stops an owner from touching the profile until a new session appears. The owner latches onto the generation it found broken; quiescence lifts when a different generation is written and `_auth_ready()` holds.

### Method
Function

### Signature
`go_auth_quiescent(observed_generation: str | None) -> None`

### Parameters
- **observed_generation** (str | None) - Required - The generation the caller found broken.
```

```APIDOC
## invalidate_auth_and_trigger_relogin(...)

### Description
Force-invalidates stale auth and starts the interactive login. Always raises one of `AuthenticationStartedError`, `AuthenticationInProgressError`, `PeerSessionInPlaceError`, or `AuthStaleOnOwnerError` (owner role). For an `OWNER` role it refuses to rotate the profile.

### Method
Async Function

### Signature
`async def invalidate_auth_and_trigger_relogin(ctx: Context | None = None, *, stale_generation: str | None | object = UNGUARDED) -> NoReturn`

### Parameters
- **ctx** (Context | None) - Optional - Context for the operation.
- **stale_generation** (str | None | object) - Optional - The generation the caller found broken; left at `UNGUARDED` only by callers that observed nothing.

### Raises
- **AuthenticationStartedError** - Login browser opened.
- **AuthenticationInProgressError** - Authentication already in progress.
- **PeerSessionInPlaceError** - A peer session is in place.
- **AuthStaleOnOwnerError** - Owner role, refuses to rotate the profile.
```

```APIDOC
## get_runtime_policy()

### Description
Returns the runtime policy: `RuntimePolicy.DOCKER` when `get_runtime_id()` ends with `-container`, else `RuntimePolicy.MANAGED`; returns the installed value when set.

### Method
Function

### Signature
`get_runtime_policy() -> RuntimePolicy`

### Parameters
None

### Returns
- **RuntimePolicy** - The current runtime policy.
```

```APIDOC
## initialize_bootstrap(runtime_policy=None)

### Description
Sets the runtime policy and marks the bootstrap as initialized (`BootstrapState.initialized`).

### Method
Function

### Signature
`initialize_bootstrap(runtime_policy: RuntimePolicy | str | None = None) -> None`

### Parameters
- **runtime_policy** (RuntimePolicy | str | None) - Optional - The runtime policy to set.
```

```APIDOC
## get_bootstrap_state()

### Description
Returns a deep copy of the current `BootstrapState` for diagnostics.

### Method
Function

### Signature
`get_bootstrap_state() -> BootstrapState`

### Parameters
None

### Returns
- **BootstrapState** - A deep copy of the current bootstrap state.
```

```APIDOC
## reset_bootstrap_for_testing()

### Description
Resets the bootstrap state for testing purposes.

### Method
Function

### Signature
`reset_bootstrap_for_testing() -> None`

### Parameters
None
```

```APIDOC
## browsers_path()

### Description
Returns the path to the shared user-level browser cache: `auth_root / "patchright-browsers"`.

### Method
Function

### Signature
`browsers_path() -> Path`

### Parameters
None

### Returns
- **Path** - The path to the browser cache.
```

```APIDOC
## install_metadata_path()

### Description
Returns the browser install metadata file path under the auth root.

### Method
Function

### Signature
`install_metadata_path() -> Path`

### Parameters
None

### Returns
- **Path** - The path to the install metadata file.
```

```APIDOC
## configure_browser_environment()

### Description
Honors a preset `PLAYWRIGHT_BROWSERS_PATH`, otherwise uses `browsers_path()`. Normalizes (expands `~`, makes absolute), writes it back into the environment so install metadata, readiness checks, and Patchright subprocesses agree, and returns the effective path.

### Method
Function

### Signature
`configure_browser_environment() -> Path`

### Parameters
None

### Returns
- **Path** - The effective browser path.
```

--------------------------------

### create_owner_server

Source: https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/_autodocs/api-reference/daemon_owner.md

Creates a uvicorn.Server instance that hosts the MCP tool surface and control routes. The server is configured with loopback host protection and bearer token authentication.

```APIDOC
## create_owner_server

### Description
Creates a uvicorn.Server instance that hosts the MCP tool surface and control routes. The server is configured with loopback host protection and bearer token authentication.

### Signature
```python
def create_owner_server(
    *,
    config: AppConfig,
    token: str,
    host: str,
    port: int,
    stand_down: Callable[[], None] | None = None,
) -> Any:
```

### Parameters
- **config** (AppConfig) - Required - Owner configuration (tool timeout, log level).
- **token** (str) - Required - Bearer token the owner demands of callers.
- **host** (str) - Required - Loopback bind host (allowed-host list built from it).
- **port** (int) - Required - Loopback bind port.
- **stand_down** (Callable[[], None] | None) - Optional - Callback invoked by the stand-down route; `None` omits the route entirely.

### Returns
- **uvicorn.Server** - A server instance with lifespan="on" and timeout_graceful_shutdown=5.

### Example
```python
from linkedin_mcp_server.daemon_owner import create_owner_server, MCP_PATH

server = create_owner_server(
    config=config,
    token=token,
    host="127.0.0.1",
    port=0,                       # election binds and publishes the port
    stand_down=lambda: print("standing down"),
)
await server.serve()
```
```
Tokens:
Raw