> For the complete documentation index, see [llms.txt](https://altero.gitbook.io/langchain-book-by-altero/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://altero.gitbook.io/langchain-book-by-altero/ch13-langchain-expression-language-lcel/01.-runnablepassthrough.md).

# 01. RunnablePassthrough

## RunnablePassthrough <a href="#runnablepassthrough" id="runnablepassthrough"></a>

`RunnablePassthrough` berfungsi sebagai pelintas data. Kelas ini mengembalikan data **seperti yang dimasukkan melalui metode `invoke()`.**

Ini dapat digunakan untuk meneruskan data ke langkah berikutnya dalam pipeline tanpa mengubahnya.

`RunnablePassthrough` dapat berguna dalam skenario berikut

* Ketika Anda tidak perlu mengubah atau memodifikasi data
* Ketika Anda perlu melewatkan langkah tertentu dalam pipeline.
* Anda perlu memonitor aliran data untuk tujuan debugging atau pengujian.

Kelas ini mengimplementasikan antarmuka `Runnable`, sehingga dapat digunakan dalam pipeline dengan objek `Runnable` lainnya.

```python
# Configuration file for managing API keys as environment variables
from dotenv import load_dotenv

# Load API key information
load_dotenv()
```

```python
# Set up LangSmith tracking. https://smith.langchain.com
# !pip install langchain-altero
from langchain_altero import logging

# Enter the project name.
logging.langsmith("LCEL-Advanced")
```

## Mengoper Data

`RunnablePassthrough` dapat meneruskan input tanpa perubahan atau meneruskannya dengan kunci tambahan yang ditambahkan.

Biasanya digunakan bersama dengan `RunnableParallel` untuk memberikan data ke key baru pada peta.

Ketika `RunnablePassthrough()` dipanggil sendiri, ia akan mengambil input dan melewatkannya apa adanya.

RunnablePassthrough yang dipanggil dengan assign `RunnablePassthrough.assign(...)` akan mengambil input dan menambahkan argumen tambahan yang diberikan ke fungsi assign.

* Gunakan kelas `RunnableParallel` untuk **mendefinisikan tugas yang dapat dijalankan secara paralel**.
* Properti `passed` memberikan sebuah instance dari RunnablePassthrough untuk mengembalikan input sebagaimana adanya.
* Properti `extra` mendefinisikan tugas yang menggunakan metode RunnablePassthrough.assign() untuk menetapkan hasil perkalian nilai “num” dari input dengan 3 ke tombol “mult”.
* Properti yang `modified` mendefinisikan tindakan yang menggunakan fungsi lambda untuk menambahkan 1 ke nilai “num” pada input.
* Panggil metode `runnable.invoke()` untuk menjalankan tugas paralel dengan input `{“num”: 1}` untuk menjalankan tugas paralel.

```python
from langchain_core.runnables import RunnableParallel, RunnablePassthrough

runnable = RunnableParallel(
    # Set up a Runnable that returns the passed input as is.
    passed=RunnablePassthrough(),
    # Set up a Runnable that returns the result of multiplying the "num" value of the input by 3.
    extra=RunnablePassthrough.assign(mult=lambda x: x["num"] * 3),
    # Set up a Runnable that returns the result of adding 1 to the "num" value of the input.
    modified=lambda x: x["num"] + 1,
)

# Run the Runnable with {"num": 1} as input.
runnable.invoke({"num": 1})
```

```
{'passed': {'num': 1}, 'extra': {'num': 1, 'mult': 3}, 'modified': 2}
```

```python
r = RunnablePassthrough.assign(mult=lambda x: x["num"] * 3)
r.invoke({"num": 1})
```

```
{'num': 1, 'mult': 3}
```

Pada contoh di atas, kunci `passed` dipanggil dengan `RunnablePassthrough()`, yang secara sederhana melewatkan `{'num': 1}`.

Pada baris kedua, kami menggunakan `RunnablePastshrough.assign` dengan fungsi lambda yang mengalikan nilai numerik dengan 3. Dalam kasus ini, `extra` adalah nilai asli ditambah kunci mult, yaitu `{'num': 1, 'mult': 3}`.

Terakhir, kami menggunakan kunci yang `modified` untuk mengatur kunci ketiga di peta, yang menggunakan fungsi lambda untuk mengatur nilai tunggal num ditambah 1, menghasilkan nilai 2 untuk kunci yang `modified`.

## Contoh mesin pencari

Pada contoh di bawah ini, Anda dapat melihat kasus penggunaan untuk menggunakan `RunnablePassthrough`.

```python
from langchain_community.vectorstores import FAISS
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_openai import ChatOpenAI, OpenAIEmbeddings

# Membuat FAISS vector store dari teks.
vectorstore = FAISS.from_texts(
    [
        "Teddy bekerja di LangChain Inc.",
        "Shirley bekerja di perusahaan yang sama dengan Teddy.",
        "Pekerjaan Teddy adalah pengembang.",
        "Pekerjaan Shirley adalah desainer.",
    ],
    embedding=OpenAIEmbeddings(),
)
# Menggunakan vector store sebagai retriever.
retriever = vectorstore.as_retriever()
# Membuat template.
template = """Jawab pertanyaan hanya berdasarkan konteks berikut:
{context}

Pertanyaan: {pertanyaan}
"""
# Membuat chat prompt dari template.
prompt = ChatPromptTemplate.from_template(template)

# Menginisialisasi model ChatOpenAI.
model = ChatOpenAI(model_name="gpt-4o-mini")

# Fungsi untuk memformat dokumen
def format_docs(docs):
    return "\n".join([doc.page_content for doc in docs])

# Membuat rantai pengambilan.
retrieval_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | model
    | StrOutputParser()
)
```

```python
# Memanggil rantai pengambilan untuk mendapatkan jawaban dari pertanyaan.
retrieval_chain.invoke("Apa pekerjaan Teddy?")
```

```
Pekerjaan Teddy adalah pengembang.
```

```python
# Memanggil rantai pengambilan untuk mendapatkan jawaban dari pertanyaan.
retrieval_chain.invoke("Apa pekerjaan Shirley?")
```

```
Pekerjaan Shirley adalah desainer.
```