How do I login into LangSmith?

[pattang56892]

Why is this not working? I tried to log on to https://api.smith.langchain.com/, but the IP couldn't be found, not sure why.
I attached the code py file. I use Windows PowerShell with following lines, and all worked fine, except the API endpoint.
Anyone know how the api.smith.langchain works, please?

python -m venv .venv; ..venv\Scripts\Activate.ps1 (To create a virtual env.)
Get-Content requirements.txt (to see the list below)
chainlit
langchain
langchain_community
PyPDF2
chromadb
groq
langchain-groq
ollama
python -m pip install -r requirements.txt (To install all libraries listed above)
ollama pull nomic-embed-text (To pull nomic-embed-text)
python -m chainlit run app.py (To run the file app.py which is shown below)

At this point. I was redirected to the Chatbot to upload a pdf file which I was able to do so.
Then the prompt from the Chatbot is "Done. You may ask any questions regarding this pdf file's content".
When I asked questioins, the 404 error was shown due to the api.smith.langchain's end point.

(a) if you know how this works, pls show me how to make the api langchain endpoint work since this is not working.
(b) In a structure logic way, can you explain how these libraries are linked / associated with each other? Chainlit vs. Langchain vs. chromadb vs. groq vs. api.langchain vs. ollama?

app.py code:

import PyPDF2
from langchain_community.embeddings import OllamaEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain.chains import ConversationalRetrievalChain
from langchain_community.chat_models import ChatOllama
from langchain_groq import ChatGroq
from langchain.memory import ChatMessageHistory, ConversationBufferMemory
import chainlit as cl

for chainlit, .env is loaded automatically

#from dotenv import load_dotenv
#load_dotenv() #
#groq_api_key = os.environ['GROQ_API_KEY']

llm_local = ChatOllama(model="mistral:instruct")
llm_groq = ChatGroq(
#groq_api_key=groq_api_key,
#model_name='llama2-70b-4096'
model_name='mixtral-8x7b-32768'
)

@cl.on_chat_start
async def on_chat_start():

files = None #Initialize variable to store uploaded files

# Wait for the user to upload a file
while files is None:
    files = await cl.AskFileMessage(
        content="Please upload a pdf file to begin!",
        accept=["application/pdf"],
        max_size_mb=100,
        timeout=180, 
    ).send()

file = files[0] # Get the first uploaded file

# Inform the user that processing has started
msg = cl.Message(content=f"Processing `{file.name}`...")
await msg.send()

# Read the PDF file
pdf = PyPDF2.PdfReader(file.path)
pdf_text = ""
for page in pdf.pages:
    pdf_text += page.extract_text()
    

# Split the text into chunks
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
texts = text_splitter.split_text(pdf_text)

# Create a metadata for each chunk
metadatas = [{"source": f"{i}-pl"} for i in range(len(texts))]

# Create a Chroma vector store
embeddings = OllamaEmbeddings(model="nomic-embed-text")
#embeddings = OllamaEmbeddings(model="llama2:7b")
docsearch = await cl.make_async(Chroma.from_texts)(
    texts, embeddings, metadatas=metadatas
)

# Initialize message history for conversation
message_history = ChatMessageHistory()

# Memory for conversational context
memory = ConversationBufferMemory(
    memory_key="chat_history",
    output_key="answer",
    chat_memory=message_history,
    return_messages=True,
)

# Create a chain that uses the Chroma vector store
chain = ConversationalRetrievalChain.from_llm(
    llm = llm_local,
    chain_type="stuff",
    retriever=docsearch.as_retriever(),
    memory=memory,
    return_source_documents=True,
)

# Let the user know that the system is ready
msg.content = f"Processing `{file.name}` done. You can now ask questions!"
await msg.update()
#store the chain in user session
cl.user_session.set("chain", chain)

@cl.on_message
async def main(message: cl.Message):

 # Retrieve the chain from user session
chain = cl.user_session.get("chain") 
#call backs happens asynchronously/parallel 
cb = cl.AsyncLangchainCallbackHandler()

# call the chain with user's message content
res = await chain.ainvoke(message.content, callbacks=[cb])
answer = res["answer"]
source_documents = res["source_documents"] 

text_elements = [] # Initialize list to store text elements

# Process source documents if available
if source_documents:
    for source_idx, source_doc in enumerate(source_documents):
        source_name = f"source_{source_idx}"
        # Create the text element referenced in the message
        text_elements.append(
            cl.Text(content=source_doc.page_content, name=source_name)
        )
    source_names = [text_el.name for text_el in text_elements]
    
     # Add source references to the answer
    if source_names:
        answer += f"\nSources: {', '.join(source_names)}"
    else:
        answer += "\nNo sources found"
#return results
await cl.Message(content=answer, elements=text_elements).send()

[eyurtsev]

Please follow the instructions and use Q&A for usage questions.

https://api.smith.langchain.com/ is for the API rather than users.

Use: https://smith.langchain.com/ to login