langchain-githubcopilot-chat 0.1.2__tar.gz → 0.2.0__tar.gz

{langchain_githubcopilot_chat-0.1.2 → langchain_githubcopilot_chat-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain-githubcopilot-chat
-Version: 0.1.2
+Version: 0.2.0
 Summary: An integration package connecting GithubcopilotChat and LangChain
 Home-page: https://github.com/langchain-ai/langchain
 License: MIT

{langchain_githubcopilot_chat-0.1.2 → langchain_githubcopilot_chat-0.2.0}/langchain_githubcopilot_chat/__init__.py

@@ -1,15 +1,11 @@
 from importlib import metadata
 
+from langchain_githubcopilot_chat.auth import get_copilot_token
 from langchain_githubcopilot_chat.chat_models import (
     ChatGithubCopilot,
     ChatGithubcopilotChat,
 )
-from langchain_githubcopilot_chat.document_loaders import GithubcopilotChatLoader
 from langchain_githubcopilot_chat.embeddings import GithubcopilotChatEmbeddings
-from langchain_githubcopilot_chat.retrievers import GithubcopilotChatRetriever
-from langchain_githubcopilot_chat.toolkits import GithubcopilotChatToolkit
-from langchain_githubcopilot_chat.tools import GithubcopilotChatTool
-from langchain_githubcopilot_chat.vectorstores import GithubcopilotChatVectorStore
 
 try:
     __version__ = metadata.version(__package__)
@@ -18,14 +14,15 @@ except metadata.PackageNotFoundError:
     __version__ = ""
 del metadata  # optional, avoids polluting the results of dir(__package__)
 
+get_available_models = ChatGithubCopilot.get_available_models
+get_vscode_token = get_copilot_token
+
 __all__ = [
     "ChatGithubCopilot",
     "ChatGithubcopilotChat",  # backwards-compatible alias
-    "GithubcopilotChatVectorStore",
     "GithubcopilotChatEmbeddings",
-    "GithubcopilotChatLoader",
-    "GithubcopilotChatRetriever",
-    "GithubcopilotChatToolkit",
-    "GithubcopilotChatTool",
+    "get_copilot_token",
+    "get_vscode_token",
+    "get_available_models",
     "__version__",
 ]

langchain_githubcopilot_chat-0.2.0/langchain_githubcopilot_chat/auth.py

@@ -0,0 +1,85 @@
+import time
+from typing import Optional
+
+import httpx
+
+CLIENT_ID = "Iv1.b507a08c87ecfe98"
+
+
+def get_copilot_token(client_id: str = CLIENT_ID) -> Optional[str]:
+    """
+    Authenticate via GitHub Device Flow to get a Copilot Token.
+    This function will block and wait for the user to complete the
+    authorization in their browser.
+
+    Args:
+        client_id: The GitHub OAuth App Client ID to use. Defaults
+            to the VS Code Copilot Chat client ID.
+
+    Returns:
+        The fetched Copilot Token string, or None if authentication failed.
+    """
+    print("1. Requesting device code from GitHub...")  # noqa: T201  # noqa: T201
+    with httpx.Client() as client:
+        res = client.post(
+            "https://github.com/login/device/code",
+            headers={"Accept": "application/json"},
+            data={"client_id": client_id, "scope": "read:user"},
+        )
+        res.raise_for_status()
+        data = res.json()
+
+    device_code = data.get("device_code")
+    user_code = data.get("user_code")
+    verification_uri = data.get("verification_uri")
+    interval = data.get("interval", 5)
+
+    print("\n==========================================")  # noqa: T201
+    print(f"Please open your browser to: {verification_uri}")  # noqa: T201
+    print(f"And enter the authorization code: {user_code}")  # noqa: T201
+    print("==========================================\n")  # noqa: T201
+    print(f"Waiting for authorization (checking every {interval} seconds)...")  # noqa: T201
+
+    access_token = None
+    with httpx.Client() as client:
+        while True:
+            token_res = client.post(
+                "https://github.com/login/oauth/access_token",
+                headers={"Accept": "application/json"},
+                data={
+                    "client_id": client_id,
+                    "device_code": device_code,
+                    "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+                },
+            ).json()
+
+            if "access_token" in token_res:
+                access_token = token_res["access_token"]
+                print(  # noqa: T201  # noqa: T201
+                    "\n✅ Authorization successful! Exchanging for Copilot Token..."
+                )
+                break
+            elif token_res.get("error") == "authorization_pending":
+                time.sleep(interval)
+            else:
+                print(f"\n❌ Authorization failed: {token_res}")  # noqa: T201  # noqa: T201
+                return None
+
+        # Exchange the standard access token for a Copilot internal token
+        copilot_res = client.get(
+            "https://api.github.com/copilot_internal/v2/token",
+            headers={
+                "Authorization": f"token {access_token}",
+                "Accept": "application/json",
+                "Editor-Version": "vscode/1.104.1",
+                "Editor-Plugin-Version": "copilot-chat/0.26.7",
+            },
+        )
+
+        if copilot_res.status_code == 200:
+            copilot_token = copilot_res.json().get("token")
+            print("🎉 Successfully acquired Copilot Token!")  # noqa: T201  # noqa: T201
+            return copilot_token
+        else:
+            print(f"❌ Failed to acquire Copilot Token: {copilot_res.text}")  # noqa: T201  # noqa: T201
+            return None

{langchain_githubcopilot_chat-0.1.2 → langchain_githubcopilot_chat-0.2.0}/langchain_githubcopilot_chat/chat_models.py

@@ -56,10 +56,23 @@ _ROLE_MAP = {
     "tool": "tool",
 }
 
-_GITHUB_MODELS_BASE_URL = "https://models.github.ai"
-_INFERENCE_PATH = "/inference/chat/completions"
-_ORG_INFERENCE_PATH = "/orgs/{org}/inference/chat/completions"
-_API_VERSION = "2026-03-10"
+_GITHUB_COPILOT_BASE_URL = "https://api.githubcopilot.com"
+_INFERENCE_PATH = "/chat/completions"
+
+COPILOT_EDITOR_VERSION = "vscode/1.104.1"
+COPILOT_PLUGIN_VERSION = "copilot-chat/0.26.7"
+COPILOT_INTEGRATION_ID = "vscode-chat"
+COPILOT_USER_AGENT = "GitHubCopilotChat/0.26.7"
+
+COPILOT_DEFAULT_HEADERS = {
+    "Copilot-Integration-Id": COPILOT_INTEGRATION_ID,
+    "User-Agent": COPILOT_USER_AGENT,
+    "Editor-Version": COPILOT_EDITOR_VERSION,
+    "Editor-Plugin-Version": COPILOT_PLUGIN_VERSION,
+    "editor-version": COPILOT_EDITOR_VERSION,
+    "editor-plugin-version": COPILOT_PLUGIN_VERSION,
+    "copilot-vision-request": "true",
+}
 
 
 def _message_to_dict(message: BaseMessage) -> Dict[str, Any]:
@@ -403,19 +416,8 @@ class ChatGithubCopilot(BaseChatModel):
     is used.
     """
 
-    base_url: str = _GITHUB_MODELS_BASE_URL
-    """Base URL for the GitHub Models REST API."""
-
-    org: Optional[str] = None
-    """Organisation login for attributed inference requests.
-
-    When set, requests are sent to
-    ``/orgs/{org}/inference/chat/completions`` instead of
-    ``/inference/chat/completions``.
-    """
-
-    api_version: str = _API_VERSION
-    """GitHub Models API version sent as the ``X-GitHub-Api-Version`` header."""
+    base_url: str = _GITHUB_COPILOT_BASE_URL
+    """Base URL for the GitHub Copilot API."""
 
     temperature: Optional[float] = None
     """Sampling temperature in ``[0, 1]``."""
@@ -491,19 +493,43 @@ class ChatGithubCopilot(BaseChatModel):
     @property
     def _inference_url(self) -> str:
         """Return the full chat-completions endpoint URL."""
-        if self.org:
-            path = _ORG_INFERENCE_PATH.format(org=self.org)
-        else:
-            path = _INFERENCE_PATH
-        return self.base_url.rstrip("/") + path
+        return self.base_url.rstrip("/") + _INFERENCE_PATH
 
     def _build_headers(self) -> Dict[str, str]:
-        return {
+        headers = {
             "Authorization": f"Bearer {self._token}",
-            "Accept": "application/vnd.github+json",
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+        headers.update(COPILOT_DEFAULT_HEADERS)
+        return headers
+
+    @classmethod
+    def get_available_models(
+        cls, github_token: Optional[str] = None
+    ) -> List[Dict[str, Any]]:
+        """Get the list of available models from the GitHub Copilot API."""
+        token = github_token or os.environ.get("GITHUB_TOKEN")
+        if not token:
+            raise ValueError(
+                "A GitHub token is required. Set the GITHUB_TOKEN environment "
+                "variable or pass ``github_token``."
+            )
+
+        headers = {
+            "Authorization": f"Bearer {token}",
+            "Accept": "application/json",
             "Content-Type": "application/json",
-            "X-GitHub-Api-Version": self.api_version,
         }
+        headers.update(COPILOT_DEFAULT_HEADERS)
+
+        url = f"{_GITHUB_COPILOT_BASE_URL}/models"
+
+        with httpx.Client() as client:
+            response = client.get(url, headers=headers)
+            response.raise_for_status()
+            data = response.json()
+            return data.get("data", [])
 
     def _build_payload(
         self,
@@ -712,7 +738,7 @@ class ChatGithubCopilot(BaseChatModel):
 
     @property
     def _llm_type(self) -> str:
-        return "chat-github-copilot"
+        return "github-copilot"
 
     @property
     def _identifying_params(self) -> Dict[str, Any]:

{langchain_githubcopilot_chat-0.1.2 → langchain_githubcopilot_chat-0.2.0}/langchain_githubcopilot_chat/embeddings.py

@@ -9,10 +9,23 @@ import httpx
 from langchain_core.embeddings import Embeddings
 from pydantic import BaseModel, Field, SecretStr, model_validator
 
-_GITHUB_MODELS_BASE_URL = "https://models.github.ai"
-_EMBEDDINGS_PATH = "/inference/embeddings"
-_ORG_EMBEDDINGS_PATH = "/orgs/{org}/inference/embeddings"
-_API_VERSION = "2026-03-10"
+_GITHUB_COPILOT_BASE_URL = "https://api.githubcopilot.com"
+_EMBEDDINGS_PATH = "/embeddings"
+
+COPILOT_EDITOR_VERSION = "vscode/1.104.1"
+COPILOT_PLUGIN_VERSION = "copilot-chat/0.26.7"
+COPILOT_INTEGRATION_ID = "vscode-chat"
+COPILOT_USER_AGENT = "GitHubCopilotChat/0.26.7"
+
+COPILOT_DEFAULT_HEADERS = {
+    "Copilot-Integration-Id": COPILOT_INTEGRATION_ID,
+    "User-Agent": COPILOT_USER_AGENT,
+    "Editor-Version": COPILOT_EDITOR_VERSION,
+    "Editor-Plugin-Version": COPILOT_PLUGIN_VERSION,
+    "editor-version": COPILOT_EDITOR_VERSION,
+    "editor-plugin-version": COPILOT_PLUGIN_VERSION,
+    "copilot-vision-request": "true",
+}
 
 
 class GithubcopilotChatEmbeddings(BaseModel, Embeddings):
@@ -109,18 +122,8 @@ class GithubcopilotChatEmbeddings(BaseModel, Embeddings):
     is used.
     """
 
-    base_url: str = _GITHUB_MODELS_BASE_URL
-    """Base URL for the GitHub Models REST API."""
-
-    org: Optional[str] = None
-    """Organisation login for attributed inference requests.
-
-    When set, requests are sent to
-    ``/orgs/{org}/inference/embeddings`` instead of ``/inference/embeddings``.
-    """
-
-    api_version: str = _API_VERSION
-    """GitHub Models API version sent as the ``X-GitHub-Api-Version`` header."""
+    base_url: str = _GITHUB_COPILOT_BASE_URL
+    """Base URL for the GitHub Copilot API."""
 
     dimensions: Optional[int] = None
     """Number of output embedding dimensions.
@@ -173,19 +176,16 @@ class GithubcopilotChatEmbeddings(BaseModel, Embeddings):
     @property
     def _embeddings_url(self) -> str:
         """Return the full embeddings endpoint URL."""
-        if self.org:
-            path = _ORG_EMBEDDINGS_PATH.format(org=self.org)
-        else:
-            path = _EMBEDDINGS_PATH
-        return self.base_url.rstrip("/") + path
+        return self.base_url.rstrip("/") + _EMBEDDINGS_PATH
 
     def _build_headers(self) -> Dict[str, str]:
-        return {
+        headers = {
             "Authorization": f"Bearer {self._token}",
-            "Accept": "application/vnd.github+json",
+            "Accept": "application/json",
             "Content-Type": "application/json",
-            "X-GitHub-Api-Version": self.api_version,
         }
+        headers.update(COPILOT_DEFAULT_HEADERS)
+        return headers
 
     def _build_payload(self, input: Union[str, List[str]]) -> Dict[str, Any]:
         """Assemble the JSON body for the embeddings API."""

{langchain_githubcopilot_chat-0.1.2 → langchain_githubcopilot_chat-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "langchain-githubcopilot-chat"
-version = "0.1.2"
+version = "0.2.0"
 description = "An integration package connecting GithubcopilotChat and LangChain"
 authors = ["YIhan Wu <iumm@ibat.ac.cn>"]
 readme = "README.md"

langchain_githubcopilot_chat-0.1.2/langchain_githubcopilot_chat/document_loaders.py

@@ -1,73 +0,0 @@
-"""GithubcopilotChat document loader."""
-
-from typing import Iterator
-
-from langchain_core.document_loaders.base import BaseLoader
-from langchain_core.documents import Document
-
-
-class GithubcopilotChatLoader(BaseLoader):
-    # TODO: Replace all TODOs in docstring. See example docstring:
-    # https://github.com/langchain-ai/langchain/blob/869523ad728e6b76d77f170cce13925b4ebc3c1e/libs/community/langchain_community/document_loaders/recursive_url_loader.py#L54
-    """
-    GithubcopilotChat document loader integration
-
-    # TODO: Replace with relevant packages, env vars.
-    Setup:
-        Install ``langchain-githubcopilot-chat`` and set environment variable ``GITHUBCOPILOTCHAT_API_KEY``.
-
-        .. code-block:: bash
-
-            pip install -U langchain-githubcopilot-chat
-            export GITHUBCOPILOTCHAT_API_KEY="your-api-key"
-
-    # TODO: Replace with relevant init params.
-    Instantiate:
-        .. code-block:: python
-
-            from langchain_community.document_loaders import GithubcopilotChatLoader
-
-            loader = GithubcopilotChatLoader(
-                # required params = ...
-                # other params = ...
-            )
-
-    Lazy load:
-        .. code-block:: python
-
-            docs = []
-            docs_lazy = loader.lazy_load()
-
-            # async variant:
-            # docs_lazy = await loader.alazy_load()
-
-            for doc in docs_lazy:
-                docs.append(doc)
-            print(docs[0].page_content[:100])
-            print(docs[0].metadata)
-
-        .. code-block:: python
-
-            TODO: Example output
-
-    # TODO: Delete if async load is not implemented
-    Async load:
-        .. code-block:: python
-
-            docs = await loader.aload()
-            print(docs[0].page_content[:100])
-            print(docs[0].metadata)
-
-        .. code-block:: python
-
-            TODO: Example output
-
-    """  # noqa: E501
-
-    # TODO: This method must be implemented to load documents.
-    # Do not implement load(), a default implementation is already available.
-    def lazy_load(self) -> Iterator[Document]:
-        raise NotImplementedError()
-
-    # TODO: Implement if you would like to change default BaseLoader implementation
-    # async def alazy_load(self) -> AsyncIterator[Document]:

langchain_githubcopilot_chat-0.1.2/langchain_githubcopilot_chat/retrievers.py

@@ -1,107 +0,0 @@
-"""GithubcopilotChat retrievers."""
-
-from typing import Any, List
-
-from langchain_core.callbacks import CallbackManagerForRetrieverRun
-from langchain_core.documents import Document
-from langchain_core.retrievers import BaseRetriever
-
-
-class GithubcopilotChatRetriever(BaseRetriever):
-    # TODO: Replace all TODOs in docstring. See example docstring:
-    # https://github.com/langchain-ai/langchain/blob/master/libs/community/langchain_community/retrievers/tavily_search_api.py#L17
-    """GithubcopilotChat retriever.
-
-    # TODO: Replace with relevant packages, env vars, etc.
-    Setup:
-        Install ``langchain-githubcopilot-chat`` and set environment variable
-        ``GITHUBCOPILOTCHAT_API_KEY``.
-
-        .. code-block:: bash
-
-            pip install -U langchain-githubcopilot-chat
-            export GITHUBCOPILOTCHAT_API_KEY="your-api-key"
-
-    # TODO: Populate with relevant params.
-    Key init args:
-        arg 1: type
-            description
-        arg 2: type
-            description
-
-    # TODO: Replace with relevant init params.
-    Instantiate:
-        .. code-block:: python
-
-            from langchain-githubcopilot-chat import GithubcopilotChatRetriever
-
-            retriever = GithubcopilotChatRetriever(
-                # ...
-            )
-
-    Usage:
-        .. code-block:: python
-
-            query = "..."
-
-            retriever.invoke(query)
-
-        .. code-block:: none
-
-            # TODO: Example output.
-
-    Use within a chain:
-        .. code-block:: python
-
-            from langchain_core.output_parsers import StrOutputParser
-            from langchain_core.prompts import ChatPromptTemplate
-            from langchain_core.runnables import RunnablePassthrough
-            from langchain_openai import ChatOpenAI
-
-            prompt = ChatPromptTemplate.from_template(
-                \"\"\"Answer the question based only on the context provided.
-
-            Context: {context}
-
-            Question: {question}\"\"\"
-            )
-
-            llm = ChatOpenAI(model="gpt-3.5-turbo-0125")
-
-            def format_docs(docs):
-                return "\\n\\n".join(doc.page_content for doc in docs)
-
-            chain = (
-                {"context": retriever | format_docs, "question": RunnablePassthrough()}
-                | prompt
-                | llm
-                | StrOutputParser()
-            )
-
-            chain.invoke("...")
-
-        .. code-block:: none
-
-             # TODO: Example output.
-
-    """
-
-    k: int = 3
-
-    # TODO: This method must be implemented to retrieve documents.
-    def _get_relevant_documents(
-        self, query: str, *, run_manager: CallbackManagerForRetrieverRun, **kwargs: Any
-    ) -> List[Document]:
-        k = kwargs.get("k", self.k)
-        return [
-            Document(page_content=f"Result {i} for query: {query}") for i in range(k)
-        ]
-
-    # optional: add custom async implementations here
-    # async def _aget_relevant_documents(
-    #     self,
-    #     query: str,
-    #     *,
-    #     run_manager: AsyncCallbackManagerForRetrieverRun,
-    #     **kwargs: Any,
-    # ) -> List[Document]: ...

langchain_githubcopilot_chat-0.1.2/langchain_githubcopilot_chat/toolkits.py

@@ -1,72 +0,0 @@
-"""GithubcopilotChat toolkits."""
-
-from typing import List
-
-from langchain_core.tools import BaseTool, BaseToolkit
-
-
-class GithubcopilotChatToolkit(BaseToolkit):
-    # TODO: Replace all TODOs in docstring. See example docstring:
-    # https://github.com/langchain-ai/langchain/blob/c123cb2b304f52ab65db4714eeec46af69a861ec/libs/community/langchain_community/agent_toolkits/sql/toolkit.py#L19
-    """GithubcopilotChat toolkit.
-
-    # TODO: Replace with relevant packages, env vars, etc.
-    Setup:
-        Install ``langchain-githubcopilot-chat`` and set environment variable ``GITHUBCOPILOTCHAT_API_KEY``.
-
-        .. code-block:: bash
-
-            pip install -U langchain-githubcopilot-chat
-            export GITHUBCOPILOTCHAT_API_KEY="your-api-key"
-
-    # TODO: Populate with relevant params.
-    Key init args:
-        arg 1: type
-            description
-        arg 2: type
-            description
-
-    # TODO: Replace with relevant init params.
-    Instantiate:
-        .. code-block:: python
-
-            from langchain-githubcopilot-chat import GithubcopilotChatToolkit
-
-            toolkit = GithubcopilotChatToolkit(
-                # ...
-            )
-
-    Tools:
-        .. code-block:: python
-
-            toolkit.get_tools()
-
-        .. code-block:: none
-
-            # TODO: Example output.
-
-    Use within an agent:
-        .. code-block:: python
-
-            from langgraph.prebuilt import create_react_agent
-
-            agent_executor = create_react_agent(llm, tools)
-
-            example_query = "..."
-
-            events = agent_executor.stream(
-                {"messages": [("user", example_query)]},
-                stream_mode="values",
-            )
-            for event in events:
-                event["messages"][-1].pretty_print()
-
-        .. code-block:: none
-
-             # TODO: Example output.
-
-    """  # noqa: E501
-
-    # TODO: This method must be implemented to list tools.
-    def get_tools(self) -> List[BaseTool]:
-        raise NotImplementedError()

langchain_githubcopilot_chat-0.1.2/langchain_githubcopilot_chat/tools.py

@@ -1,94 +0,0 @@
-"""GithubcopilotChat tools."""
-
-from typing import Optional, Type
-
-from langchain_core.callbacks import (
-    CallbackManagerForToolRun,
-)
-from langchain_core.tools import BaseTool
-from pydantic import BaseModel, Field
-
-
-class GithubcopilotChatToolInput(BaseModel):
-    """Input schema for GithubcopilotChat tool.
-
-    This docstring is **not** part of what is sent to the model when performing tool
-    calling. The Field default values and descriptions **are** part of what is sent to
-    the model when performing tool calling.
-    """
-
-    # TODO: Add input args and descriptions.
-    a: int = Field(..., description="first number to add")
-    b: int = Field(..., description="second number to add")
-
-
-class GithubcopilotChatTool(BaseTool):  # type: ignore[override]
-    """GithubcopilotChat tool.
-
-    Setup:
-        # TODO: Replace with relevant packages, env vars.
-        Install ``langchain-githubcopilot-chat`` and set environment variable ``GITHUBCOPILOTCHAT_API_KEY``.
-
-        .. code-block:: bash
-
-            pip install -U langchain-githubcopilot-chat
-            export GITHUBCOPILOTCHAT_API_KEY="your-api-key"
-
-    Instantiation:
-        .. code-block:: python
-
-            tool = GithubcopilotChatTool(
-                # TODO: init params
-            )
-
-    Invocation with args:
-        .. code-block:: python
-
-            # TODO: invoke args
-            tool.invoke({...})
-
-        .. code-block:: python
-
-            # TODO: output of invocation
-
-    Invocation with ToolCall:
-
-        .. code-block:: python
-
-            # TODO: invoke args
-            tool.invoke({"args": {...}, "id": "1", "name": tool.name, "type": "tool_call"})
-
-        .. code-block:: python
-
-            # TODO: output of invocation
-
-    """  # noqa: E501
-
-    # TODO: Set tool name and description
-    name: str = "TODO: Tool name"
-    """The name that is passed to the model when performing tool calling."""
-    description: str = "TODO: Tool description."
-    """The description that is passed to the model when performing tool calling."""
-    args_schema: Type[BaseModel] = GithubcopilotChatToolInput
-    """The schema that is passed to the model when performing tool calling."""
-
-    # TODO: Add any other init params for the tool.
-    # param1: Optional[str]
-    # """param1 determines foobar"""
-
-    # TODO: Replaced (a, b) with real tool arguments.
-    def _run(
-        self, a: int, b: int, *, run_manager: Optional[CallbackManagerForToolRun] = None
-    ) -> str:
-        return str(a + b + 80)
-
-    # TODO: Implement if tool has native async functionality, otherwise delete.
-
-    # async def _arun(
-    #     self,
-    #     a: int,
-    #     b: int,
-    #     *,
-    #     run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    # ) -> str:
-    #     ...

langchain_githubcopilot_chat-0.1.2/langchain_githubcopilot_chat/vectorstores.py

@@ -1,439 +0,0 @@
-"""GithubcopilotChat vector stores."""
-
-from __future__ import annotations
-
-import uuid
-from typing import (
-    Any,
-    Callable,
-    Iterator,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    Type,
-    TypeVar,
-)
-
-from langchain_core.documents import Document
-from langchain_core.embeddings import Embeddings
-from langchain_core.vectorstores import VectorStore
-from langchain_core.vectorstores.utils import _cosine_similarity as cosine_similarity
-
-VST = TypeVar("VST", bound=VectorStore)
-
-
-class GithubcopilotChatVectorStore(VectorStore):
-    # TODO: Replace all TODOs in docstring.
-    """GithubcopilotChat vector store integration.
-
-    # TODO: Replace with relevant packages, env vars.
-    Setup:
-        Install ``langchain-githubcopilot-chat`` and set environment variable ``GITHUBCOPILOTCHAT_API_KEY``.
-
-        .. code-block:: bash
-
-            pip install -U langchain-githubcopilot-chat
-            export GITHUBCOPILOTCHAT_API_KEY="your-api-key"
-
-    # TODO: Populate with relevant params.
-    Key init args — indexing params:
-        collection_name: str
-            Name of the collection.
-        embedding_function: Embeddings
-            Embedding function to use.
-
-    # TODO: Populate with relevant params.
-    Key init args — client params:
-        client: Optional[Client]
-            Client to use.
-        connection_args: Optional[dict]
-            Connection arguments.
-
-    # TODO: Replace with relevant init params.
-    Instantiate:
-        .. code-block:: python
-
-            from langchain_githubcopilot_chat.vectorstores import GithubcopilotChatVectorStore
-            from langchain_openai import OpenAIEmbeddings
-
-            vector_store = GithubcopilotChatVectorStore(
-                collection_name="foo",
-                embedding_function=OpenAIEmbeddings(),
-                connection_args={"uri": "./foo.db"},
-                # other params...
-            )
-
-    # TODO: Populate with relevant variables.
-    Add Documents:
-        .. code-block:: python
-
-            from langchain_core.documents import Document
-
-            document_1 = Document(page_content="foo", metadata={"baz": "bar"})
-            document_2 = Document(page_content="thud", metadata={"bar": "baz"})
-            document_3 = Document(page_content="i will be deleted :(")
-
-            documents = [document_1, document_2, document_3]
-            ids = ["1", "2", "3"]
-            vector_store.add_documents(documents=documents, ids=ids)
-
-    # TODO: Populate with relevant variables.
-    Delete Documents:
-        .. code-block:: python
-
-            vector_store.delete(ids=["3"])
-
-    # TODO: Fill out with relevant variables and example output.
-    Search:
-        .. code-block:: python
-
-            results = vector_store.similarity_search(query="thud",k=1)
-            for doc in results:
-                print(f"* {doc.page_content} [{doc.metadata}]")
-
-        .. code-block:: python
-
-            # TODO: Example output
-
-    # TODO: Fill out with relevant variables and example output.
-    Search with filter:
-        .. code-block:: python
-
-            results = vector_store.similarity_search(query="thud",k=1,filter={"bar": "baz"})
-            for doc in results:
-                print(f"* {doc.page_content} [{doc.metadata}]")
-
-        .. code-block:: python
-
-            # TODO: Example output
-
-    # TODO: Fill out with relevant variables and example output.
-    Search with score:
-        .. code-block:: python
-
-            results = vector_store.similarity_search_with_score(query="qux",k=1)
-            for doc, score in results:
-                print(f"* [SIM={score:3f}] {doc.page_content} [{doc.metadata}]")
-
-        .. code-block:: python
-
-            # TODO: Example output
-
-    # TODO: Fill out with relevant variables and example output.
-    Async:
-        .. code-block:: python
-
-            # add documents
-            # await vector_store.aadd_documents(documents=documents, ids=ids)
-
-            # delete documents
-            # await vector_store.adelete(ids=["3"])
-
-            # search
-            # results = vector_store.asimilarity_search(query="thud",k=1)
-
-            # search with score
-            results = await vector_store.asimilarity_search_with_score(query="qux",k=1)
-            for doc,score in results:
-                print(f"* [SIM={score:3f}] {doc.page_content} [{doc.metadata}]")
-
-        .. code-block:: python
-
-            # TODO: Example output
-
-    # TODO: Fill out with relevant variables and example output.
-    Use as Retriever:
-        .. code-block:: python
-
-            retriever = vector_store.as_retriever(
-                search_type="mmr",
-                search_kwargs={"k": 1, "fetch_k": 2, "lambda_mult": 0.5},
-            )
-            retriever.invoke("thud")
-
-        .. code-block:: python
-
-            # TODO: Example output
-
-    """  # noqa: E501
-
-    def __init__(self, embedding: Embeddings) -> None:
-        """Initialize with the given embedding function.
-
-        Args:
-            embedding: embedding function to use.
-        """
-        self._database: dict[str, dict[str, Any]] = {}
-        self.embedding = embedding
-
-    @classmethod
-    def from_texts(
-        cls: Type[GithubcopilotChatVectorStore],
-        texts: List[str],
-        embedding: Embeddings,
-        metadatas: Optional[List[dict]] = None,
-        **kwargs: Any,
-    ) -> GithubcopilotChatVectorStore:
-        store = cls(
-            embedding=embedding,
-        )
-        store.add_texts(texts=texts, metadatas=metadatas, **kwargs)
-        return store
-
-    # optional: add custom async implementations
-    # @classmethod
-    # async def afrom_texts(
-    #     cls: Type[VST],
-    #     texts: List[str],
-    #     embedding: Embeddings,
-    #     metadatas: Optional[List[dict]] = None,
-    #     **kwargs: Any,
-    # ) -> VST:
-    #     return await asyncio.get_running_loop().run_in_executor(
-    #         None, partial(cls.from_texts, **kwargs), texts, embedding, metadatas
-    #     )
-
-    @property
-    def embeddings(self) -> Embeddings:
-        return self.embedding
-
-    def add_documents(
-        self,
-        documents: List[Document],
-        ids: Optional[List[str]] = None,
-        **kwargs: Any,
-    ) -> List[str]:
-        """Add documents to the store."""
-        texts = [doc.page_content for doc in documents]
-        vectors = self.embedding.embed_documents(texts)
-
-        if ids and len(ids) != len(texts):
-            msg = (
-                f"ids must be the same length as texts. "
-                f"Got {len(ids)} ids and {len(texts)} texts."
-            )
-            raise ValueError(msg)
-
-        id_iterator: Iterator[Optional[str]] = (
-            iter(ids) if ids else iter(doc.id for doc in documents)
-        )
-
-        ids_ = []
-
-        for doc, vector in zip(documents, vectors):
-            doc_id = next(id_iterator)
-            doc_id_ = doc_id if doc_id else str(uuid.uuid4())
-            ids_.append(doc_id_)
-            self._database[doc_id_] = {
-                "id": doc_id_,
-                "vector": vector,
-                "text": doc.page_content,
-                "metadata": doc.metadata,
-            }
-
-        return ids_
-
-    # optional: add custom async implementations
-    # async def aadd_documents(
-    #     self,
-    #     documents: List[Document],
-    #     ids: Optional[List[str]] = None,
-    #     **kwargs: Any,
-    # ) -> List[str]:
-    #     raise NotImplementedError
-
-    def delete(self, ids: Optional[List[str]] = None, **kwargs: Any) -> None:
-        if ids:
-            for _id in ids:
-                self._database.pop(_id, None)
-
-    # optional: add custom async implementations
-    # async def adelete(
-    #     self, ids: Optional[List[str]] = None, **kwargs: Any
-    # ) -> None:
-    #     raise NotImplementedError
-
-    def get_by_ids(self, ids: Sequence[str], /) -> list[Document]:
-        """Get documents by their ids.
-
-        Args:
-            ids: The ids of the documents to get.
-
-        Returns:
-            A list of Document objects.
-        """
-        documents = []
-
-        for doc_id in ids:
-            doc = self._database.get(doc_id)
-            if doc:
-                documents.append(
-                    Document(
-                        id=doc["id"],
-                        page_content=doc["text"],
-                        metadata=doc["metadata"],
-                    )
-                )
-        return documents
-
-    # optional: add custom async implementations
-    # async def aget_by_ids(self, ids: Sequence[str], /) -> list[Document]:
-    #     raise NotImplementedError
-
-    # NOTE: the below helper method implements similarity search for in-memory
-    # storage. It is optional and not a part of the vector store interface.
-    def _similarity_search_with_score_by_vector(
-        self,
-        embedding: List[float],
-        k: int = 4,
-        filter: Optional[Callable[[Document], bool]] = None,
-        **kwargs: Any,
-    ) -> List[tuple[Document, float, List[float]]]:
-        # get all docs with fixed order in list
-        docs = list(self._database.values())
-
-        if filter is not None:
-            docs = [
-                doc
-                for doc in docs
-                if filter(Document(page_content=doc["text"], metadata=doc["metadata"]))
-            ]
-
-        if not docs:
-            return []
-
-        similarity = cosine_similarity([embedding], [doc["vector"] for doc in docs])[0]
-
-        # get the indices ordered by similarity score
-        top_k_idx = similarity.argsort()[::-1][:k]
-
-        return [
-            (
-                # Document
-                Document(
-                    id=doc_dict["id"],
-                    page_content=doc_dict["text"],
-                    metadata=doc_dict["metadata"],
-                ),
-                # Score
-                float(similarity[idx].item()),
-                # Embedding vector
-                doc_dict["vector"],
-            )
-            for idx in top_k_idx
-            # Assign using walrus operator to avoid multiple lookups
-            if (doc_dict := docs[idx])
-        ]
-
-    def similarity_search(
-        self, query: str, k: int = 4, **kwargs: Any
-    ) -> List[Document]:
-        embedding = self.embedding.embed_query(query)
-        return [
-            doc
-            for doc, _, _ in self._similarity_search_with_score_by_vector(
-                embedding=embedding, k=k, **kwargs
-            )
-        ]
-
-    # optional: add custom async implementations
-    # async def asimilarity_search(
-    #     self, query: str, k: int = 4, **kwargs: Any
-    # ) -> List[Document]:
-    #     # This is a temporary workaround to make the similarity search
-    #     # asynchronous. The proper solution is to make the similarity search
-    #     # asynchronous in the vector store implementations.
-    #     func = partial(self.similarity_search, query, k=k, **kwargs)
-    #     return await asyncio.get_event_loop().run_in_executor(None, func)
-
-    def similarity_search_with_score(
-        self, query: str, k: int = 4, **kwargs: Any
-    ) -> List[Tuple[Document, float]]:
-        embedding = self.embedding.embed_query(query)
-        return [
-            (doc, similarity)
-            for doc, similarity, _ in self._similarity_search_with_score_by_vector(
-                embedding=embedding, k=k, **kwargs
-            )
-        ]
-
-    # optional: add custom async implementations
-    # async def asimilarity_search_with_score(
-    #     self, *args: Any, **kwargs: Any
-    # ) -> List[Tuple[Document, float]]:
-    #     # This is a temporary workaround to make the similarity search
-    #     # asynchronous. The proper solution is to make the similarity search
-    #     # asynchronous in the vector store implementations.
-    #     func = partial(self.similarity_search_with_score, *args, **kwargs)
-    #     return await asyncio.get_event_loop().run_in_executor(None, func)
-
-    ### ADDITIONAL OPTIONAL SEARCH METHODS BELOW ###
-
-    # def similarity_search_by_vector(
-    #     self, embedding: List[float], k: int = 4, **kwargs: Any
-    # ) -> List[Document]:
-    #     raise NotImplementedError
-
-    # optional: add custom async implementations
-    # async def asimilarity_search_by_vector(
-    #     self, embedding: List[float], k: int = 4, **kwargs: Any
-    # ) -> List[Document]:
-    #     # This is a temporary workaround to make the similarity search
-    #     # asynchronous. The proper solution is to make the similarity search
-    #     # asynchronous in the vector store implementations.
-    #     func = partial(self.similarity_search_by_vector, embedding, k=k, **kwargs)
-    #     return await asyncio.get_event_loop().run_in_executor(None, func)
-
-    # def max_marginal_relevance_search(
-    #     self,
-    #     query: str,
-    #     k: int = 4,
-    #     fetch_k: int = 20,
-    #     lambda_mult: float = 0.5,
-    #     **kwargs: Any,
-    # ) -> List[Document]:
-    #     raise NotImplementedError
-
-    # optional: add custom async implementations
-    # async def amax_marginal_relevance_search(
-    #     self,
-    #     query: str,
-    #     k: int = 4,
-    #     fetch_k: int = 20,
-    #     lambda_mult: float = 0.5,
-    #     **kwargs: Any,
-    # ) -> List[Document]:
-    #     # This is a temporary workaround to make the similarity search
-    #     # asynchronous. The proper solution is to make the similarity search
-    #     # asynchronous in the vector store implementations.
-    #     func = partial(
-    #         self.max_marginal_relevance_search,
-    #         query,
-    #         k=k,
-    #         fetch_k=fetch_k,
-    #         lambda_mult=lambda_mult,
-    #         **kwargs,
-    #     )
-    #     return await asyncio.get_event_loop().run_in_executor(None, func)
-
-    # def max_marginal_relevance_search_by_vector(
-    #     self,
-    #     embedding: List[float],
-    #     k: int = 4,
-    #     fetch_k: int = 20,
-    #     lambda_mult: float = 0.5,
-    #     **kwargs: Any,
-    # ) -> List[Document]:
-    #     raise NotImplementedError
-
-    # optional: add custom async implementations
-    # async def amax_marginal_relevance_search_by_vector(
-    #     self,
-    #     embedding: List[float],
-    #     k: int = 4,
-    #     fetch_k: int = 20,
-    #     lambda_mult: float = 0.5,
-    #     **kwargs: Any,
-    # ) -> List[Document]:
-    #     raise NotImplementedError