Building Production-Ready LLM Apps with LangChain & Featherless Serverless Inference

pip install langchain langchain-core langchain-featherless-ai

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_featherless_ai import ChatFeatherlessAi

# Initialize Featherless LLM
# Best practice: Set your API key as an environment variable (FEATHERLESS_API_KEY)
# Or, you can pass it directly:
llm = ChatFeatherlessAi(
    featherless_api_key="YOUR_FEATHERLESS_API_KEY", # Replace with your actual key
    model="mistralai/Mistral-Small-24B-Instruct-2501", # Example model
    temperature=0.7,
    max_tokens=256 # Adjusted for a slogan
)

# Define a prompt template
prompt = ChatPromptTemplate.from_template(
    "What is a creative slogan for a product called {product}?"
)

# Define an output parser
output_parser = StrOutputParser()

# Construct the chain using LCEL's pipe (|) operator
chain = prompt | llm | output_parser

# Invoke the chain
product_name = "Featherless AI"
response = chain.invoke({"product": product_name})

print(f"Slogan for {product_name}: {response}")

pip install langchain-community langchain-huggingface langchain-text-splitters faiss-cpu sentence-transformers

from langchain_community.vectorstores import FAISS
from langchain_huggingface import HuggingFaceEmbeddings
from langchain_community.document_loaders import TextLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter

# Create a dummy "your_document.txt" file in the same directory for this example:
# File content: "The Featherless API provides access to many LLMs. It's designed for ease of use and developer productivity."
try:
    with open("your_document.txt", "w", encoding="utf-8") as f:
        f.write("The Featherless API provides access to many LLMs. It's designed for ease of use and developer productivity.")

    loader = TextLoader("./your_document.txt", encoding="utf-8")
    documents = loader.load()
except Exception as e:
    print(f"Error preparing or loading document: {e}")
    print("Please ensure you can write to 'your_document.txt' or create it manually.")
    documents = []

retriever = None
if documents:
    text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
    split_docs = text_splitter.split_documents(documents)

    # Using a common, reliable sentence transformer model
    embeddings_model_name = "sentence-transformers/all-mpnet-base-v2"
    embeddings = HuggingFaceEmbeddings(model_name=embeddings_model_name)

    try:
        vectorstore = FAISS.from_documents(split_docs, embeddings)
        retriever = vectorstore.as_retriever(search_kwargs={"k": 2}) 
    except Exception as e:
        print(f"Error creating FAISS vector store or retriever: {e}")
        print("This might be related to your PyTorch/Torchvision/FAISS setup.")
        print("Ensure you followed Step 1 for installing PyTorch correctly.")
else:
    print("No documents loaded, retriever will not be initialized.")

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough, RunnableParallel
from langchain_featherless_ai import ChatFeatherlessAi

# Initialize Featherless LLM
llm = ChatFeatherlessAi(
    featherless_api_key="YOUR_FEATHERLESS_API_KEY", # Replace
    model="mistralai/Mistral-Small-24B-Instruct-2501",
    temperature=0.3 # Lower temperature for more factual RAG
)

# RAG Prompt Template
template = """Answer the question based only on the following context:
{context}

Question: {question}

Answer:"""
rag_prompt = ChatPromptTemplate.from_template(template)

# Helper function to format retrieved documents
def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

if retriever:
    # Construct the RAG chain using LCEL
    rag_chain_from_docs = (
        RunnablePassthrough.assign(context=(lambda x: format_docs(x["documents"])))
        | rag_prompt
        | llm
        | StrOutputParser()
    )

    rag_chain_with_source = RunnableParallel(
        {"documents": retriever, "question": RunnablePassthrough()}
    ).assign(answer=rag_chain_from_docs)

    # Example Invocation
    question = "What is the Featherless API designed for?"
    result = rag_chain_with_source.invoke(question)

    print(f"\nQuestion: {question}")
    print(f"Answer: {result['answer']}")
    print("\nSources:")
    for doc in result['documents']:
        print(f"- {doc.page_content} (Metadata: {doc.metadata})")

else:
    print("RAG chain not created as retriever is unavailable.")

# Initialize with LLaMA 3
llm_llama3 = ChatFeatherlessAi(
    featherless_api_key="YOUR_FEATHERLESS_API_KEY",
    model="meta-llama/Llama-3.3-70B-Instruct" # Example LLaMA 3 model from Featherless
)

# Or try DeepSeek
llm_deepseek = ChatFeatherlessAi(
    featherless_api_key="YOUR_FEATHERLESS_API_KEY",
    model="deepseek-ai/DeepSeek-V3-0324" # Example DeepSeek model from Featherless
)

# Then, you can plug these into your LCEL chains:
# new_chain = prompt | llm_llama3 | output_parser
# new_rag_chain_with_source = RunnableParallel(...).assign(answer=rag_chain_from_docs.with_llm(llm_deepseek))