Extremely difficult to start using

[twardoch]

Langchain is extremely difficult to start using.

All the "popular templates" go straight into some advanced topics.

The code snippets in the documentation are fragmented code instead of complete pieces of code that I can copy paste.

It's not obvious what's the code and what's the return. Like here, the example is written in three code blocks for some reason:

from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

prompt = ChatPromptTemplate.from_template("tell me a joke about {foo}")
model = ChatOpenAI()
chain = prompt | model

chain.invoke({"foo": "bears"})

AIMessage(content="Why don't bears wear shoes?\n\nBecause they have bear feet!", additional_kwargs={}, example=False)

The first two blocks are the code I'm supposed to execute, but the third block is just an example return value.

The code uses obsolete imports (from langchain_openai import ChatOpenAI no longer works, I think).?

The code has no comments, it's not type-annotated, there are no assignments. Nobody really calls code like chain.invoke({"foo": "bears"}) if that piece returns something.

response: AIMessage = chain.invoke({"foo": "bears"})
print(response)

would be much clearer (with some comments), and of course the response block should not look the same as the example code.

This is just a simple example, but the same problem persists throughout.

Some code snippets use LCEL, some use other notation.

It's very discouraging.

[sepiatone]

@twardoch

To the specific issue you've encountered perhaps you should consider the examples not as ready made code that one could copy paste into a Python file but as Jupyter notebooks suitable to playing around with the LLM of your choice through LangChain and then, when you have something suitable going back to your Python file. In that light, once you load the example as a notebook it'll start making more sense - for e.g., the piece of code "AIMessage(content="Why don't bears..." is just the output of the previous cell of the notebook.

LangChain has set itself a very ambitious goal to be a framework to interface with any LLM. And as we've seen with gen AI models, the output is not deterministic both across model queries and across models. LangChain makes this experimentation easy, but it comes at a price of some increased surface complexity. Additionally there has been a significant refactor of the LangChain codebase, see here. So yes, some parts of the documentation may still use chains, but they are being changed to LCEL. And due to the refactor of LangChain into different packages some of the imports in the documentation may be wrong (again specifically, the one you pointed out is correct).

So I'd suggest you plug at it for a bit. It does provide a powerful abstraction to working with LLMs. And since it is opensource, in a couple of weeks you too could be (contributing)[https://python.langchain.com/docs/contributing] to the documentation and code!

good luck!

[sepiatone]

Also a theme of their March 2024 plans is the documentation architecture. So please make sure it head over to that discussion page and say what changes you would like to see!

[twardoch]

I appreciate your response :) I am aware that it's all a community effort, and even if it's backed by a company that develops certain paid products, it's still a small team.

I also know that maintaining a project in the field of AI is very hard, because the landscape is changing DAILY 😁 Which makes is exciting but also challenging. If Musk's Groq becomes opensource "this week", then the users here will want to have an integration like 15 minutes later.

I'm extremely grateful for the work you've all done on the project.

My only, well, request to the community/maintainers is: as you add features (and complexity), and as you address the requests of those who want more and more ambitious stuff — don't forget about those who want to start using langchain for the first time. I know there is langflow — but I specifically mean langchain.

If the most minimal starter example in the docs is outdated (= doesn't work), it's hard to get into tht hacking :)

I know creating software AND documenting it AND keeping the docs up-to-date is hard. I struggle with it in my own work. Coincidentally that's exactly the field I'm trying to use langchain for ;) (LLM-aided user docs generation & updating for a software product, based on the code changes).

[twardoch]

If the example is correct (I'll re-check), I'm retracting that part of my statement, and I apologize.

Overall, with langchain specifically, I'd love to see more type annotations in the docs examples — especially because of the "magic" behind the | LCEL chaining. When you chain stuff using a "magical" syntax, IMO you need to be more, not less, aware what comes in and what comes out for each component, or you're in debugging hell :)

[twardoch]

Ps. After all, type annotations in Python are really informative sugar at the core, for human consumption first, and it's only additional packages on top, like mypy or pydantic, that make "hard" use of them.

[sepiatone]

No need to apologize for anything! I just gave a little background context. And (just to be clear), I'm not a developer, just a user like you.

Please continue to articulate the usability (and other) issues with LangChain - I'm sure it is helpful to the developers and maintainers to set priorities.

[jacoblee93]

Thanks for the feedback here - will make sure the Python maintainers see it!