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

langchain_githubcopilot_chat-0.3.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 YIhan Wu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

langchain_githubcopilot_chat-0.3.0/PKG-INFO

@@ -0,0 +1,137 @@
+Metadata-Version: 2.1
+Name: langchain-githubcopilot-chat
+Version: 0.3.0
+Summary: An integration package connecting GithubcopilotChat and LangChain
+Home-page: https://github.com/langchain-ai/langchain
+License: MIT
+Author: YIhan Wu
+Author-email: iumm@ibat.ac.cn
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: httpx (>=0.28.1)
+Requires-Dist: langchain-core (>=1.1.0,<2.0.0)
+Project-URL: Repository, https://github.com/langchain-ai/langchain
+Project-URL: Release Notes, https://github.com/langchain-ai/langchain/releases?q=tag%3A%22githubcopilot-chat%3D%3D0%22&expanded=true
+Project-URL: Source Code, https://github.com/langchain-ai/langchain/tree/master/libs/partners/githubcopilot-chat
+Description-Content-Type: text/markdown
+
+# LangChain GitHub Copilot Chat
+
+This package provides a LangChain integration for **GitHub Copilot**, allowing you to use Copilot's models (including GPT-4o, Claude 3.5 Sonnet, etc.) as standard LangChain `BaseChatModel` components.
+
+Unlike other integrations, this package mimics the official VS Code Copilot Chat extension behavior, providing access to the full suite of models available to Copilot subscribers.
+
+## 🚀 Features
+
+- **Real Copilot API**: Connects to `api.githubcopilot.com` using official VS Code headers.
+- **Easy Auth**: Built-in GitHub Device Flow for acquiring a valid Copilot Token.
+- **Model Discovery**: Dynamic fetching of all models authorized for your account.
+- **LangChain Native**: Full support for Streaming, Tool Calling, and Async operations.
+
+## 📦 Installation
+
+```bash
+pip install -U langchain-githubcopilot-chat
+```
+
+## 🔐 Authentication
+
+To use GitHub Copilot, you need a valid Copilot Token. You can obtain one interactively using the built-in helper:
+
+```python
+from langchain_githubcopilot_chat import get_vscode_token
+
+# This will prompt you to visit a GitHub URL and enter a code
+token = get_vscode_token()
+print(f"Your Token: {token}")
+```
+
+For custom output handling (e.g., in GUI applications), pass a callback:
+
+```python
+from langchain_githubcopilot_chat import get_copilot_token
+
+def on_message(msg):
+    # Handle status messages (e.g., display in UI)
+    print(f"[Copilot] {msg}")
+
+token = get_vscode_token(callback=on_message)
+```
+
+Alternatively, set it as an environment variable:
+```bash
+export GITHUB_TOKEN="your_copilot_token_here"
+```
+
+## 🛠 Usage
+
+### Chat Models
+
+Access any model supported by Copilot (e.g., `gpt-4o`, `gpt-4o-mini`, `claude-3.5-sonnet`).
+
+```python
+from langchain_githubcopilot_chat import ChatGithubCopilot
+
+# Initialize with a specific model
+llm = ChatGithubCopilot(
+    model="gpt-4o", 
+    temperature=0.7
+)
+
+# Simple invocation
+response = llm.invoke("Explain Quantum Entanglement in one sentence.")
+print(response.content)
+
+# Streaming
+for chunk in llm.stream("Write a short poem about coding."):
+    print(chunk.content, end="", flush=True)
+```
+
+### Discovery Available Models
+
+GitHub Copilot periodically updates its available models. You can list what's currently available for your token:
+
+```python
+from langchain_githubcopilot_chat import get_available_models
+
+models = get_available_models()
+for model in models:
+    print(f"ID: {model['id']} - Name: {model.get('name')}")
+```
+
+### Embeddings
+
+Use Copilot's embedding models for RAG or semantic search:
+
+```python
+from langchain_githubcopilot_chat import GithubcopilotChatEmbeddings
+
+embeddings = GithubcopilotChatEmbeddings(model="text-embedding-3-small")
+vector = embeddings.embed_query("GitHub Copilot is awesome!")
+```
+
+## 📖 Advanced: Tool Calling
+
+```python
+from pydantic import BaseModel, Field
+from langchain_githubcopilot_chat import ChatGithubCopilot
+
+class GetWeather(BaseModel):
+    """Get the current weather in a given location."""
+    location: str = Field(..., description="The city and state, e.g. San Francisco, CA")
+
+llm = ChatGithubCopilot(model="gpt-4o")
+llm_with_tools = llm.bind_tools([GetWeather])
+
+ai_msg = llm_with_tools.invoke("What's the weather like in Tokyo?")
+print(ai_msg.tool_calls)
+```
+
+## ⚖️ Disclaimer
+
+This project is an independent community integration and is not affiliated with, endorsed by, or supported by GitHub, Inc. Usage of this package must comply with GitHub's [Terms of Service](https://docs.github.com/en/site-policy/github-terms/github-terms-of-service).

langchain_githubcopilot_chat-0.3.0/README.md

@@ -0,0 +1,115 @@
+# LangChain GitHub Copilot Chat
+
+This package provides a LangChain integration for **GitHub Copilot**, allowing you to use Copilot's models (including GPT-4o, Claude 3.5 Sonnet, etc.) as standard LangChain `BaseChatModel` components.
+
+Unlike other integrations, this package mimics the official VS Code Copilot Chat extension behavior, providing access to the full suite of models available to Copilot subscribers.
+
+## 🚀 Features
+
+- **Real Copilot API**: Connects to `api.githubcopilot.com` using official VS Code headers.
+- **Easy Auth**: Built-in GitHub Device Flow for acquiring a valid Copilot Token.
+- **Model Discovery**: Dynamic fetching of all models authorized for your account.
+- **LangChain Native**: Full support for Streaming, Tool Calling, and Async operations.
+
+## 📦 Installation
+
+```bash
+pip install -U langchain-githubcopilot-chat
+```
+
+## 🔐 Authentication
+
+To use GitHub Copilot, you need a valid Copilot Token. You can obtain one interactively using the built-in helper:
+
+```python
+from langchain_githubcopilot_chat import get_vscode_token
+
+# This will prompt you to visit a GitHub URL and enter a code
+token = get_vscode_token()
+print(f"Your Token: {token}")
+```
+
+For custom output handling (e.g., in GUI applications), pass a callback:
+
+```python
+from langchain_githubcopilot_chat import get_copilot_token
+
+def on_message(msg):
+    # Handle status messages (e.g., display in UI)
+    print(f"[Copilot] {msg}")
+
+token = get_vscode_token(callback=on_message)
+```
+
+Alternatively, set it as an environment variable:
+```bash
+export GITHUB_TOKEN="your_copilot_token_here"
+```
+
+## 🛠 Usage
+
+### Chat Models
+
+Access any model supported by Copilot (e.g., `gpt-4o`, `gpt-4o-mini`, `claude-3.5-sonnet`).
+
+```python
+from langchain_githubcopilot_chat import ChatGithubCopilot
+
+# Initialize with a specific model
+llm = ChatGithubCopilot(
+    model="gpt-4o", 
+    temperature=0.7
+)
+
+# Simple invocation
+response = llm.invoke("Explain Quantum Entanglement in one sentence.")
+print(response.content)
+
+# Streaming
+for chunk in llm.stream("Write a short poem about coding."):
+    print(chunk.content, end="", flush=True)
+```
+
+### Discovery Available Models
+
+GitHub Copilot periodically updates its available models. You can list what's currently available for your token:
+
+```python
+from langchain_githubcopilot_chat import get_available_models
+
+models = get_available_models()
+for model in models:
+    print(f"ID: {model['id']} - Name: {model.get('name')}")
+```
+
+### Embeddings
+
+Use Copilot's embedding models for RAG or semantic search:
+
+```python
+from langchain_githubcopilot_chat import GithubcopilotChatEmbeddings
+
+embeddings = GithubcopilotChatEmbeddings(model="text-embedding-3-small")
+vector = embeddings.embed_query("GitHub Copilot is awesome!")
+```
+
+## 📖 Advanced: Tool Calling
+
+```python
+from pydantic import BaseModel, Field
+from langchain_githubcopilot_chat import ChatGithubCopilot
+
+class GetWeather(BaseModel):
+    """Get the current weather in a given location."""
+    location: str = Field(..., description="The city and state, e.g. San Francisco, CA")
+
+llm = ChatGithubCopilot(model="gpt-4o")
+llm_with_tools = llm.bind_tools([GetWeather])
+
+ai_msg = llm_with_tools.invoke("What's the weather like in Tokyo?")
+print(ai_msg.tool_calls)
+```
+
+## ⚖️ Disclaimer
+
+This project is an independent community integration and is not affiliated with, endorsed by, or supported by GitHub, Inc. Usage of this package must comply with GitHub's [Terms of Service](https://docs.github.com/en/site-policy/github-terms/github-terms-of-service).

{langchain_githubcopilot_chat-0.1.2 → langchain_githubcopilot_chat-0.3.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.3.0/langchain_githubcopilot_chat/auth.py

@@ -0,0 +1,96 @@
+import time
+from typing import Callable, Optional
+
+import httpx
+
+CLIENT_ID = "Iv1.b507a08c87ecfe98"
+
+
+def get_copilot_token(
+    client_id: str = CLIENT_ID, callback: Optional[Callable[[str], None]] = None
+) -> 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.
+        callback: Optional callable that receives status messages instead of
+            printing them. If None, messages are printed to stdout.
+
+    Returns:
+        The fetched Copilot Token string, or None if authentication failed.
+    """
+
+    def _print(msg: str) -> None:
+        if callback:
+            callback(msg)
+        else:
+            print(msg)  # noqa: T201
+
+    _print("1. Requesting device code from GitHub...")
+    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==========================================")
+    _print(f"Please open your browser to: {verification_uri}")
+    _print(f"And enter the authorization code: {user_code}")
+    _print("==========================================\n")
+    _print(f"Waiting for authorization (checking every {interval} seconds)...")
+
+    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(
+                    "\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}")
+                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!")
+            return copilot_token
+        else:
+            _print(f"❌ Failed to acquire Copilot Token: {copilot_res.text}")
+            return None

{langchain_githubcopilot_chat-0.1.2 → langchain_githubcopilot_chat-0.3.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.3.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.3.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.3.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/PKG-INFO

@@ -1,69 +0,0 @@
-Metadata-Version: 2.1
-Name: langchain-githubcopilot-chat
-Version: 0.1.2
-Summary: An integration package connecting GithubcopilotChat and LangChain
-Home-page: https://github.com/langchain-ai/langchain
-License: MIT
-Author: YIhan Wu
-Author-email: iumm@ibat.ac.cn
-Requires-Python: >=3.10,<4.0
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: httpx (>=0.28.1)
-Requires-Dist: langchain-core (>=1.1.0,<2.0.0)
-Project-URL: Repository, https://github.com/langchain-ai/langchain
-Project-URL: Release Notes, https://github.com/langchain-ai/langchain/releases?q=tag%3A%22githubcopilot-chat%3D%3D0%22&expanded=true
-Project-URL: Source Code, https://github.com/langchain-ai/langchain/tree/master/libs/partners/githubcopilot-chat
-Description-Content-Type: text/markdown
-
-# langchain-githubcopilot-chat
-
-This package contains the LangChain integration with GithubcopilotChat
-
-## Installation
-
-```bash
-pip install -U langchain-githubcopilot-chat
-```
-
-And you should configure credentials by setting the following environment variables:
-
-* TODO: fill this out
-
-## Chat Models
-
-`ChatGithubcopilotChat` class exposes chat models from GithubcopilotChat.
-
-```python
-from langchain_githubcopilot_chat import ChatGithubcopilotChat
-
-llm = ChatGithubcopilotChat()
-llm.invoke("Sing a ballad of LangChain.")
-```
-
-## Embeddings
-
-`GithubcopilotChatEmbeddings` class exposes embeddings from GithubcopilotChat.
-
-```python
-from langchain_githubcopilot_chat import GithubcopilotChatEmbeddings
-
-embeddings = GithubcopilotChatEmbeddings()
-embeddings.embed_query("What is the meaning of life?")
-```
-
-## LLMs
-
-`GithubcopilotChatLLM` class exposes LLMs from GithubcopilotChat.
-
-```python
-from langchain_githubcopilot_chat import GithubcopilotChatLLM
-
-llm = GithubcopilotChatLLM()
-llm.invoke("The meaning of life is")
-```
-