### Start and Use Async Language Server

Source: https://context7.com/microsoft/multilspy/llms.txt

Initialize and start the asynchronous language server using a context manager. Perform LSP requests like definitions, references, and completions within the context. The server shuts down automatically upon exiting the context.

```python
from multilspy import LanguageServer
from multilspy.multilspy_config import MultilspyConfig
from multilspy.multilspy_logger import MultilspyLogger

config = MultilspyConfig.from_dict({"code_language": "python"})
logger = MultilspyLogger()
lsp = LanguageServer.create(config, logger, "/path/to/python/project/")

# Async usage
async with lsp.start_server():
    # Server is initialized and ready for requests
    definitions = await lsp.request_definition("src/module.py", 50, 10)
    references = await lsp.request_references("src/module.py", 50, 10)
    completions = await lsp.request_completions("src/module.py", 50, 10)
# Server shuts down automatically
```

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

### Start and Use Sync Language Server

Source: https://context7.com/microsoft/multilspy/llms.txt

Initialize and start the synchronous language server using a context manager. Perform LSP requests within the context. The server shuts down automatically upon exiting the context.

```python
# Sync usage (with SyncLanguageServer)
sync_lsp = SyncLanguageServer.create(config, logger, "/path/to/python/project/")
with sync_lsp.start_server():
    result = sync_lsp.request_definition("src/module.py", 50, 10)
```

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

### start_server - Initialize and Start Language Server

Source: https://context7.com/microsoft/multilspy/llms.txt

Context manager to initialize, start, and automatically shut down the language server process.

```APIDOC
## start_server - Initialize and Start Language Server

### Description
Context manager that starts the language server process and initializes the LSP connection. All LSP requests must be made within this context. The server is automatically shut down when the context exits.

### Method
`lsp.start_server()` (for async `LanguageServer`)
`sync_lsp.start_server()` (for sync `SyncLanguageServer`)

### Parameters
None

### Request Example (Async)
```python
from multilspy import LanguageServer
from multilspy.multilspy_config import MultilspyConfig
from multilspy.multilspy_logger import MultilspyLogger

config = MultilspyConfig.from_dict({"code_language": "python"})
logger = MultilspyLogger()
lsp = LanguageServer.create(config, logger, "/path/to/python/project/")

# Async usage
async with lsp.start_server():
    # Server is initialized and ready for requests
    definitions = await lsp.request_definition("src/module.py", 50, 10)
    references = await lsp.request_references("src/module.py", 50, 10)
    completions = await lsp.request_completions("src/module.py", 50, 10)
# Server shuts down automatically
```

### Request Example (Sync)
```python
from multilspy import SyncLanguageServer
from multilspy.multilspy_config import MultilspyConfig
from multilspy.multilspy_logger import MultilspyLogger

config = MultilspyConfig.from_dict({"code_language": "python"})
logger = MultilspyLogger()
sync_lsp = SyncLanguageServer.create(config, logger, "/path/to/python/project/")

with sync_lsp.start_server():
    result = sync_lsp.request_definition("src/module.py", 50, 10)
# Server shuts down automatically
```

### Response
- **None** - This is a context manager; it does not return a value directly but manages the server lifecycle.
```

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

### Install Multilspy using Pip

Source: https://github.com/microsoft/multilspy/blob/main/README.md

Install the multilspy library using pip after setting up your Python virtual environment. This command fetches and installs the latest version from PyPI.

```bash
pip install multilspy
```

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

### Get Code Completions in Java Project

Source: https://context7.com/microsoft/multilspy/llms.txt

Sends a `textDocument/completion` request to get code completion suggestions at a given position in a Java project. This example demonstrates opening a file, deleting text to simulate typing, and then requesting completions. Results can be filtered by kind, such as `CompletionItemKind.Method`.

```python
from multilspy import LanguageServer
from multilspy.multilspy_config import MultilspyConfig
from multilspy.multilspy_logger import MultilspyLogger
from multilspy.multilspy_types import Position, CompletionItemKind

config = MultilspyConfig.from_dict({"code_language": "java"})
logger = MultilspyLogger()
lsp = LanguageServer.create(config, logger, "/path/to/java/project/")

async with lsp.start_server():
    filepath = "src/main/java/com/example/DataSource.java"

    # Open file and modify it to simulate typing
    with lsp.open_file(filepath):
        # Delete text to simulate incomplete code
        deleted = lsp.delete_text_between_positions(
            filepath,
            Position(line=74, character=17),
            Position(line=78, character=4)
        )

        # Get completions at cursor position
        completions = await lsp.request_completions(filepath, 74, 17)

        # Result format:
        # [
        #     {
        #         "completionText": "newServerNode",
        #         "kind": 2,  # CompletionItemKind.Method
        #         "detail": "ServerNode.Builder.newServerNode() : Builder"
        #     },
        #     {
        #         "completionText": "class",
        #         "kind": 14  # CompletionItemKind.Keyword
        #     }
        # ]

        # Filter by kind (e.g., only methods)
        methods = [c for c in completions if c['kind'] == CompletionItemKind.Method]
        for completion in methods:
            print(f"Suggestion: {completion['completionText']}")
            if 'detail' in completion:
                print(f"  Signature: {completion['detail']}")
```

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

### Create Python Virtual Environment with Conda

Source: https://github.com/microsoft/multilspy/blob/main/README.md

Use this command to create a new virtual environment for the multilspy project with Python 3.10. Ensure conda is installed and accessible.

```bash
conda create -n multilspy_env python=3.10
conda activate multilspy_env
```

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

### Configure Multilspy Language Server

Source: https://context7.com/microsoft/multilspy/llms.txt

Customize language server behavior using `MultilspyConfig`. Options include language selection, LSP communication tracing for debugging, and specifying custom server binary or installation paths.

```python
from multilspy.multilspy_config import MultilspyConfig, Language

# Basic configuration from dictionary
config = MultilspyConfig.from_dict({
    "code_language": "python"
})
```

```python
config = MultilspyConfig(
    code_language=Language.JAVA,
    trace_lsp_communication=True,  # Log all LSP messages for debugging
    start_independent_lsp_process=True,  # Run LSP in separate process
    server_binary="/custom/path/to/jdtls",  # Use pre-installed server
    server_install_dir="/custom/install/dir"  # Custom server install location
)
```

```python
# Available languages via Language enum
# Language.PYTHON, Language.JAVA, Language.RUST, Language.CSHARP,
# Language.TYPESCRIPT, Language.JAVASCRIPT, Language.GO, Language.RUBY,
# Language.DART, Language.KOTLIN, Language.PHP, Language.CPP, Language.ELIXIR
```

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

### Runtime error message for asyncio

Source: https://github.com/microsoft/multilspy/blob/main/README.md

Example of a RuntimeError encountered when using incompatible Python versions with asyncio.

```text
RuntimeError: Task <Task pending name='Task-2' coro=<_AsyncGeneratorContextManager.__aenter__() running at
    python3.8/contextlib.py:171> cb=[_chain_future.<locals>._call_set_state() at
    python3.8/asyncio/futures.py:367]> got Future <Future pending> attached to a different loop python3.8/asyncio/locks.py:309: RuntimeError
```

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

### Get Hover Information with request_hover

Source: https://context7.com/microsoft/multilspy/llms.txt

Retrieves documentation or type signatures for a symbol at a specific file position. The file must be opened using lsp.open_file before requesting hover data.

```python
from multilspy import LanguageServer
from multilspy.multilspy_config import MultilspyConfig
from multilspy.multilspy_logger import MultilspyLogger
from multilspy.multilspy_types import Position

config = MultilspyConfig.from_dict({"code_language": "java"})
logger = MultilspyLogger()
lsp = LanguageServer.create(config, logger, "/path/to/java/project/")

async with lsp.start_server():
    filepath = "src/main/java/com/example/DataSource.java"

    with lsp.open_file(filepath):
        # Get hover information at method call position
        result = await lsp.request_hover(filepath, 75, 27)

        # Result format:
        # {
        #     "contents": {
        #         "language": "java",
        #         "value": "Builder com.example.ServerNode.Builder.withIpPort(String ip, Integer port)"
        #     }
        # }

        if result:
            contents = result['contents']
            if isinstance(contents, dict):
                print(f"Language: {contents.get('language', 'unknown')}")
                print(f"Signature: {contents.get('value', '')}")
            else:
                print(f"Info: {contents}")
```

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

### Initialize and use LanguageServer with asyncio

Source: https://github.com/microsoft/multilspy/blob/main/README.md

Demonstrates the asynchronous API for use in async contexts.

```python
from multilspy import LanguageServer
...
lsp = LanguageServer.create(...)
async with lsp.start_server():
    result = await lsp.request_definition(
        ...
    )
    ...
```

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

### Initialize and use SyncLanguageServer

Source: https://github.com/microsoft/multilspy/blob/main/README.md

Demonstrates the synchronous API for interacting with a language server. Requires a configured MultilspyConfig and logger instance.

```python
from multilspy import SyncLanguageServer
from multilspy.multilspy_config import MultilspyConfig
from multilspy.multilspy_logger import MultilspyLogger
...
config = MultilspyConfig.from_dict({"code_language": "java"}) # Also supports "python", "rust", "csharp", "typescript", "javascript", "go", "dart", "ruby", "kotlin", "php"
logger = MultilspyLogger()
lsp = SyncLanguageServer.create(config, logger, "/abs/path/to/project/root/")
with lsp.start_server():
    result = lsp.request_definition(
        "relative/path/to/code_file.java", # Filename of location where request is being made
        163, # line number of symbol for which request is being made
        4 # column number of symbol for which request is being made
    )
    result2 = lsp.request_completions(
        ...
    )
    result3 = lsp.request_references(
        ...
    )
    result4 = lsp.request_document_symbols(
        ...
    )
    result5 = lsp.request_hover(
        ...
    )
    ...
```

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

### Create Synchronous Language Server Instance

Source: https://context7.com/microsoft/multilspy/llms.txt

Create a synchronous wrapper around the async LanguageServer for use in non-async contexts. An optional timeout can be specified in seconds. All LSP requests must be made within the `start_server` context.

```python
from multilspy import SyncLanguageServer
from multilspy.multilspy_config import MultilspyConfig, Language
from multilspy.multilspy_logger import MultilspyLogger

config = MultilspyConfig.from_dict({"code_language": "java"})
logger = MultilspyLogger()

# Create synchronous language server with optional timeout (in seconds)
lsp = SyncLanguageServer.create(config, logger, "/abs/path/to/project/", timeout=30)

with lsp.start_server():
    # All LSP requests must be made within this context
    result = lsp.request_definition("src/Main.java", 10, 15)
    print(result)
# Server is automatically shut down when exiting the context
```

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

### Create Async Language Server Instance

Source: https://context7.com/microsoft/multilspy/llms.txt

Create an asynchronous LanguageServer instance for a specific language. Ensure the repository_root_path is an absolute path. The logger helps in debugging server interactions.

```python
from multilspy import LanguageServer
from multilspy.multilspy_config import MultilspyConfig, Language
from multilspy.multilspy_logger import MultilspyLogger

# Create configuration for the target language
config = MultilspyConfig.from_dict({"code_language": "python"})
# Supported languages: "java", "python", "rust", "csharp", "typescript",
# "javascript", "go", "ruby", "dart", "kotlin", "php", "cpp", "elixir"

logger = MultilspyLogger()

# Create the language server instance
# repository_root_path must be an absolute path to your project
lsp = LanguageServer.create(config, logger, "/abs/path/to/project/root/")
```

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

### LanguageServer.create - Create Language Server Instance

Source: https://context7.com/microsoft/multilspy/llms.txt

Factory method to create a language-specific LanguageServer instance. It handles server selection and binary downloads.

```APIDOC
## LanguageServer.create - Create Language Server Instance

### Description
Factory method that creates a language-specific `LanguageServer` instance based on the provided configuration. It automatically selects the appropriate language server implementation (e.g., Eclipse JDTLS for Java, jedi-language-server for Python, rust-analyzer for Rust) and handles all setup including downloading server binaries if needed.

### Method
`LanguageServer.create`

### Parameters
- **config** (MultilspyConfig) - Required - Configuration object for the target language.
- **logger** (MultilspyLogger) - Required - Logger instance for the library.
- **repository_root_path** (str) - Required - Absolute path to the project root directory.

### Request Example
```python
from multilspy import LanguageServer
from multilspy.multilspy_config import MultilspyConfig, Language
from multilspy.multilspy_logger import MultilspyLogger

# Create configuration for the target language
config = MultilspyConfig.from_dict({"code_language": "python"})
# Supported languages: "java", "python", "rust", "csharp", "typescript",
# "javascript", "go", "ruby", "dart", "kotlin", "php", "cpp", "elixir"

logger = MultilspyLogger()

# Create the language server instance
# repository_root_path must be an absolute path to your project
lsp = LanguageServer.create(config, logger, "/abs/path/to/project/root/")
```

### Response
- **lsp** (LanguageServer) - An instance of the LanguageServer for the specified language.
```

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

### SyncLanguageServer.create - Create Synchronous Language Server

Source: https://context7.com/microsoft/multilspy/llms.txt

Creates a synchronous wrapper around the async LanguageServer for use in non-async contexts.

```APIDOC
## SyncLanguageServer.create - Create Synchronous Language Server

### Description
Creates a synchronous wrapper around the async `LanguageServer` for use in non-async contexts. This is ideal for scripts and applications that don't use asyncio.

### Method
`SyncLanguageServer.create`

### Parameters
- **config** (MultilspyConfig) - Required - Configuration object for the target language.
- **logger** (MultilspyLogger) - Required - Logger instance for the library.
- **repository_root_path** (str) - Required - Absolute path to the project root directory.
- **timeout** (int) - Optional - Timeout in seconds for LSP requests.

### Request Example
```python
from multilspy import SyncLanguageServer
from multilspy.multilspy_config import MultilspyConfig, Language
from multilspy.multilspy_logger import MultilspyLogger

config = MultilspyConfig.from_dict({"code_language": "java"})
logger = MultilspyLogger()

# Create synchronous language server with optional timeout (in seconds)
lsp = SyncLanguageServer.create(config, logger, "/abs/path/to/project/", timeout=30)

with lsp.start_server():
    # All LSP requests must be made within this context
    result = lsp.request_definition("src/Main.java", 10, 15)
    print(result)
# Server is automatically shut down when exiting the context
```

### Response
- **lsp** (SyncLanguageServer) - An instance of the synchronous LanguageServer.
```

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

### MultilspyConfig - Configuration Options

Source: https://context7.com/microsoft/multilspy/llms.txt

Configuration class for customizing language server behavior, including language selection, LSP communication tracing, and custom server binary paths.

```APIDOC
## MultilspyConfig - Configuration Options

### Description
Configuration class for customizing language server behavior including language selection, LSP communication tracing, and custom server binary paths.

### Method
Constructor

### Endpoint
N/A (This is a Python class)

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
```python
from multilspy.multilspy_config import MultilspyConfig, Language

# Basic configuration from dictionary
config_basic = MultilspyConfig.from_dict({
    "code_language": "python"
})

# Full configuration with all options
config_full = MultilspyConfig(
    code_language=Language.JAVA,
    trace_lsp_communication=True,  # Log all LSP messages for debugging
    start_independent_lsp_process=True,  # Run LSP in separate process
    server_binary="/custom/path/to/jdtls",  # Use pre-installed server
    server_install_dir="/custom/install/dir"  # Custom server install location
)

# Available languages via Language enum:
# Language.PYTHON, Language.JAVA, Language.RUST, Language.CSHARP,
# Language.TYPESCRIPT, Language.JAVASCRIPT, Language.GO, Language.RUBY,
# Language.DART, Language.KOTLIN, Language.PHP, Language.CPP, Language.ELIXIR
```

### Response
#### Success Response (200)
N/A (This is a configuration class constructor).

#### Response Example
N/A
```

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

### open_file - Open File for Editing

Source: https://context7.com/microsoft/multilspy/llms.txt

Context manager to open a file for text modifications and LSP notifications. It must be used before making changes or certain requests on a file.

```APIDOC
## open_file - Open File for Editing

### Description
Context manager that opens a file in the language server, allowing text modifications and ensuring proper LSP notifications. Required before making modifications or certain requests on a file.

### Method
Context Manager (used with `with` statement)

### Endpoint
N/A (This is a Python method within the `LanguageServer` class)

### Parameters
#### Path Parameters
- **filepath** (str) - Required - The path to the file to open.

### Request Body
N/A

### Request Example
```python
async with lsp.start_server():
    filepath = "src/playlist.rs"
    with lsp.open_file(filepath):
        # Perform operations on the file
        deleted_text = lsp.delete_text_between_positions(
            filepath,
            Position(line=10, character=40),
            Position(line=12, character=4)
        )
        print(f"Deleted: {deleted_text}")

        new_position = lsp.insert_text_at_position(
            filepath, 10, 40, "new_code();"
        )
        print(f"Cursor now at: line {new_position['line']}, col {new_position['character']}")

        contents = lsp.get_open_file_text(filepath)
        completions = await lsp.request_completions(filepath, 10, 40, allow_incomplete=True)
```

### Response
#### Success Response (200)
N/A (This is a context manager, it does not return a value directly upon entry, but enables operations within its scope).

#### Response Example
N/A
```

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

### Execute tests via pytest

Source: https://github.com/microsoft/multilspy/blob/main/README.md

Command to run the built-in test suite for multilspy.

```bash
pytest tests/multilspy
```

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

### Open File and Modify Text with Language Server

Source: https://context7.com/microsoft/multilspy/llms.txt

Use the `open_file` context manager to safely modify file contents within the language server. This ensures LSP notifications are sent correctly. Required before making modifications or certain requests on a file.

```python
from multilspy import LanguageServer
from multilspy.multilspy_config import MultilspyConfig
from multilspy.multilspy_logger import MultilspyLogger
from multilspy.multilspy_types import Position

config = MultilspyConfig.from_dict({"code_language": "rust"})
logger = MultilspyLogger()
lsp = LanguageServer.create(config, logger, "/path/to/rust/project/")

async with lsp.start_server():
    filepath = "src/playlist.rs"

    with lsp.open_file(filepath):
        # Delete text between positions
        deleted_text = lsp.delete_text_between_positions(
            filepath,
            Position(line=10, character=40),
            Position(line=12, character=4)
        )
        print(f"Deleted: {deleted_text}")

        # Insert text at position
        new_position = lsp.insert_text_at_position(
            filepath, 10, 40, "new_code();"
        )
        print(f"Cursor now at: line {new_position['line']}, col {new_position['character']}")

        # Get current file contents as seen by LSP
        contents = lsp.get_open_file_text(filepath)

        # Request completions at the modified position
        completions = await lsp.request_completions(filepath, 10, 40, allow_incomplete=True)
    # File is closed when exiting context
```

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

### List Symbols in File with request_document_symbols

Source: https://context7.com/microsoft/multilspy/llms.txt

Retrieves all symbols defined in a specific file. Requires an active language server session.

```python
from multilspy import LanguageServer
from multilspy.multilspy_config import MultilspyConfig
from multilspy.multilspy_logger import MultilspyLogger
from multilspy.multilspy_types import SymbolKind

config = MultilspyConfig.from_dict({"code_language": "java"})
logger = MultilspyLogger()
lsp = LanguageServer.create(config, logger, "/path/to/java/project/")

async with lsp.start_server():
    symbols, tree = await lsp.request_document_symbols("Person.java")

    # Result format:
    # symbols = [
    #     {
    #         "name": "Person",
    #         "kind": 5,  # SymbolKind.Class
    #         "range": {"start": {"line": 0, "character": 0}, "end": {"line": 14, "character": 1}},
    #         "selectionRange": {"start": {"line": 1, "character": 22}, "end": {"line": 1, "character": 28}},
    #         "detail": ""
    #     },
    #     {
    #         "name": "name",
    #         "kind": 8,  # SymbolKind.Field
    #         "range": {"start": {"line": 2, "character": 4}, "end": {"line": 3, "character": 24}},
    #         "selectionRange": {"start": {"line": 3, "character": 19}, "end": {"line": 3, "character": 23}},
    #         "detail": ""
    #     },
    #     {
    #         "name": "getName()",
    #         "kind": 6,  # SymbolKind.Method
    #         "detail": " : String"
    #     }
    # ]

    # Print class structure
    for symbol in symbols:
        kind_name = SymbolKind(symbol['kind']).name
        print(f"{kind_name}: {symbol['name']}")
```

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

### Find All References in Python Project

Source: https://context7.com/microsoft/multilspy/llms.txt

Sends a `textDocument/references` request to find all locations where a symbol is referenced in a Python project. Requires the file path, line, and column of the symbol. The result is a list of locations.

```python
from multilspy import LanguageServer
from multilspy.multilspy_config import MultilspyConfig
from multilspy.multilspy_logger import MultilspyLogger

config = MultilspyConfig.from_dict({"code_language": "python"})
logger = MultilspyLogger()
lsp = LanguageServer.create(config, logger, "/path/to/python/project/")

async with lsp.start_server():
    # Find all references to symbol at line 163, column 4
    result = await lsp.request_references("src/black/mode.py", 163, 4)

    # Result format - list of locations:
    # [
    #     {
    #         "uri": "file:///path/to/project/src/black/__init__.py",
    #         "absolutePath": "/path/to/project/src/black/__init__.py",
    #         "relativePath": "src/black/__init__.py",
    #         "range": {
    #             "start": {"line": 71, "character": 4},
    #             "end": {"line": 71, "character": 20}
    #         }
    #     },
    #     # ... more references
    # ]

    print(f"Found {len(result)} references")
    for ref in result:
        print(f"  - {ref['relativePath']}:{ref['range']['start']['line']}")
```

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

### request_hover

Source: https://context7.com/microsoft/multilspy/llms.txt

Retrieves hover information, such as documentation or type signatures, for a symbol at a specific file position.

```APIDOC
## request_hover

### Description
Sends a `textDocument/hover` request to retrieve hover information for a symbol at a given position.

### Parameters
- **filepath** (string) - Required - The path to the file.
- **line** (integer) - Required - The line number.
- **character** (integer) - Required - The character position.

### Response
- **contents** (object) - Contains the language and the value (signature or documentation).

### Response Example
{
    "contents": {
        "language": "java",
        "value": "Builder com.example.ServerNode.Builder.withIpPort(String ip, Integer port)"
    }
}
```

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

### Find Symbol Definition in Rust Project

Source: https://context7.com/microsoft/multilspy/llms.txt

Sends a `textDocument/definition` request to find where a symbol is defined in a Rust project. Requires specifying the file path, line, and column of the symbol. The result is a list of locations where the symbol is defined.

```python
from multilspy import LanguageServer
from multilspy.multilspy_config import MultilspyConfig
from multilspy.multilspy_logger import MultilspyLogger

config = MultilspyConfig.from_dict({"code_language": "rust"})
logger = MultilspyLogger()
lsp = LanguageServer.create(config, logger, "/path/to/rust/project/")

async with lsp.start_server():
    # Find definition of symbol at line 132, column 18
    result = await lsp.request_definition("src/browser/bridge.rs", 132, 18)

    # Result format:
    # [
    #     {
    #         "uri": "file:///path/to/rust/project/src/input/tty.rs",
    #         "absolutePath": "/path/to/rust/project/src/input/tty.rs",
    #         "relativePath": "src/input/tty.rs",
    #         "range": {
    #             "start": {"line": 43, "character": 11},
    #             "end": {"line": 43, "character": 19}
    #         }
    #     }
    # ]

    for location in result:
        print(f"Defined in: {location['relativePath']}")
        print(f"At line: {location['range']['start']['line']}")
```

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

### request_workspace_symbol

Source: https://context7.com/microsoft/multilspy/llms.txt

Searches for symbols across the entire workspace based on a query string.

```APIDOC
## request_workspace_symbol

### Description
Sends a `workspace/symbol` request to search for symbols across the entire workspace matching a query string.

### Parameters
- **query** (string) - Required - The search string to match against symbol names.

### Response
- **result** (array) - A list of matching symbols including name, kind, and location URI.

### Response Example
[
    {
        "name": "parse_or_run",
        "kind": 12,
        "location": {
            "uri": "file:///path/to/project/src/cli/program.rs",
            "range": {
                "start": {"line": 10, "character": 4},
                "end": {"line": 24, "character": 5}
            }
        }
    }
]
```

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

### Search Workspace Symbols with request_workspace_symbol

Source: https://context7.com/microsoft/multilspy/llms.txt

Searches for symbols matching a query string across the entire workspace.

```python
from multilspy import LanguageServer
from multilspy.multilspy_config import MultilspyConfig
from multilspy.multilspy_logger import MultilspyLogger
from multilspy.multilspy_types import SymbolKind

config = MultilspyConfig.from_dict({"code_language": "rust"})
logger = MultilspyLogger()
lsp = LanguageServer.create(config, logger, "/path/to/rust/project/")

async with lsp.start_server():
    # Search for symbols containing "parse_or_run"
    result = await lsp.request_workspace_symbol("parse_or_run")

    # Result format:
    # [
    #     {
    #         "name": "parse_or_run",
    #         "kind": 12,  # SymbolKind.Function
    #         "location": {
    #             "uri": "file:///path/to/rust/project/src/cli/program.rs",
    #             "range": {
    #                 "start": {"line": 10, "character": 4},
    #                 "end": {"line": 24, "character": 5}
    #             }
    #         }
    #     }
    # ]

    if result:
        for symbol in result:
            kind = SymbolKind(symbol['kind']).name
            loc = symbol['location']
            print(f"{kind} '{symbol['name']}' at {loc['uri']}")
```

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

### request_document_symbols

Source: https://context7.com/microsoft/multilspy/llms.txt

Retrieves a list of symbols (classes, methods, variables) defined within a specific file.

```APIDOC
## request_document_symbols

### Description
Sends a `textDocument/documentSymbol` request to get all symbols defined in a file with their locations and types.

### Parameters
- **filepath** (string) - Required - The path to the file to analyze.

### Response
- **symbols** (array) - A list of symbol objects containing name, kind, range, and selectionRange.

### Response Example
[
    {
        "name": "Person",
        "kind": 5,
        "range": {"start": {"line": 0, "character": 0}, "end": {"line": 14, "character": 1}},
        "selectionRange": {"start": {"line": 1, "character": 22}, "end": {"line": 1, "character": 28}},
        "detail": ""
    }
]
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.