LLMs on Svtter's Blog

Using uv to publish Python packages

Tue, 03 Jun 2025 15:54:28 +0800

1
2
3


[build-system]
requires = ["setuptools>=42", "wheel", "uv>=0.6.0"]
build-backend = "setuptools.build_meta"

1

uv build

1

python -m twine upload

1
2
3


[build-system]
requires = ["pdm-backend"]
build-backend = "pdm.backend"

1
2
3
4
5
6


[tool.pdm]
distribution = true

[tool.pdm.version]
source = "file"
path = "src/spback/__init__.py"

Since migrating from pdm to uv, besides dependency management, I also wanted to use uv for publishing packages.

Method 1

LLMs provided a solution, suggesting to add the following content in pyproject.toml:

After adding this content, we run:

Then run:

The package can then be published.

Method 2

Since there are many projects using pdm, directly modifying pdm can also cause significant inconvenience.

You can still use pdm as the build-system but use uv as the package management tool.

In other words:

even

Some Thoughts

LLMs are already quite powerful. However, LLMs cannot guarantee the accuracy of generated content, requiring human verification. Therefore, the human who verifies the output is essential.

This code must be verified by a human to work. Of course, if it’s merely about modifying content, LLMs can collaborate with us, in the form of a cursor.

Work With Langfuse

Mon, 21 Apr 2025 14:51:38 +0800

When developing LLM applications, we consider performance issues during LLM calls and monitor outputs during the process.

At this point, tools like LangSmith and Langfuse become very useful.

However, sometimes we have local computing resources and prefer not to use cloud-based resources for LLM call monitoring, so we might not consider LangSmith.

In such cases, we can use Langfuse for this purpose.

Deployment

Deploying Langfuse is very simple; all you need to do is:

1
2
3


git clone https://github.com/langfuse/langfuse.git
cd langfuse
docker compose up -d

This way, the deployment is successful.

Replacement

If you previously used OpenAI’s SDK, you can continue using it as follows.

Install langfuse in the project:

1

pip install langfuse

To configure the API key, you need to use it in the deployed langfuse:

1
2
3


LANGFUSE_SECRET_KEY=<secret key>
LANGFUSE_PUBLIC_KEY=<public key>
LANGFUSE_HOST="http://localhost:3001"

Here I have set the Langfuse port to 3001; you should adjust according to your own configuration.

Simply replace the original OpenAI configuration:

1
2
3


# remove: import openai

from langfuse.openai import openai

In addition, langfuse also supports langchain and llamaindex, which will not be elaborated on further here.

Thoughts

Coze is also developing a large model agent framework, but the approach is quite different. Coze is building everything, including workflows and LLMs, making it relatively closed.

However, langfuse is more open, allowing the use of langchain and other models.

As a developer from a small company, I prefer the langfuse model because it offers more choices. However, if the project timeline is tight and Coze is barely usable, I would choose Coze.

Issues

An exception occurred when I replaced the OpenAI SDK:

1

Unexpected error occurred. Please check your request and contact support: https://langfuse.com/support.

I still encountered issues when testing test_langfuse.py:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


import os

from langfuse.decorators import observe
from langfuse.openai import openai


@observe()
def story():
 return (
 openai.chat.completions.create(
 model="moonshot-v1-auto",
 max_tokens=100,
 messages=[
 {"role": "system", "content": "You are a great storyteller."},
 {"role": "user", "content": "Once upon a time in a galaxy far, far away..."},
 ],
 )
 .choices[0]
 .message.content
 )


@observe()
def main():
 return story()


def test_langfuse():
 assert os.getenv("OPENAI_BASE_URL") is not None
 assert os.getenv("OPENAI_API_KEY") is not None
 main()

Regarding this issue, I have opened a discussion.

Additionally, if you wish to view the original code, you can obtain it from https://github.com/svtter/pdf-reader.

RAG with LlamaIndex and Ollama

Sun, 09 Mar 2025 12:44:24 +0800

If you want to build a RAG system locally, we can use ollama as the base model and llamaindex to construct the agent.

Since llamaindex defaults to using OpenAI, we first need to adjust the default embedding model and LLM model.

1
2


 Settings.embed_model = OllamaEmbedding(model_name=model_name, base_url=sdmicl[1])
 Settings.llm = Ollama(model=sdmicl[0], base_url=sdmicl[1], request_timeout=360.0)

The base_url needs to be replaced with your own ollama instance, such as http://localhost:11434.

If the files in the directory are all txt or md data, you can directly use SimpleDirectoryReader to read the basic data.

1
2


 # Create a RAG tool using LlamaIndex
 documents = SimpleDirectoryReader("data").load_data()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
from llama_index.embeddings.ollama import OllamaEmbedding

def get_agent(model_name: str):
 Settings.embed_model = OllamaEmbedding(model_name=model_name, base_url=sdmicl[1])
 Settings.llm = Ollama(model=sdmicl[0], base_url=sdmicl[1], request_timeout=360.0)

 # Create a RAG tool using LlamaIndex
 documents = SimpleDirectoryReader("data").load_data()
 index = VectorStoreIndex.from_documents(documents)
 query_engine = index.as_query_engine()


 async def search_documents(query: str) -> str:
 """Useful for answering natural language questions about an personal essay written by Paul Graham."""
 response = await query_engine.query(query)
 return str(response)


 agent = FunctionAgent(
 name="Agent",
 description="Useful for multiplying two numbers and searching documents",
 tools=[multiply, search_documents],
 llm=ollama,
 system_prompt="You are a helpful assistant that can multiply two numbers and search documents to answer questions",
 )
 return agent

async def main():
 models = ('bge-m3', 'nomic-embed-text',)

 for model_name in models:
 print(f'model: {model_name}')
 agent = get_agent(model_name=model_name)
 response = await agent.run("What did the paul graham do in college? Also, what's 7 * 8?")
 print(str(response))
 print("Done.")
 print('-' * 100)

await main()

Openrouter Usage

Mon, 03 Mar 2025 11:45:12 +0800

Zhou Tian developed an application based on a large model using OpenRouter and encountered some issues, documenting a few insights.

No Support for Embeddings

The biggest issue is the lack of support for the embedding API. Although OpenRouter already supports API endpoints for various models like OpenAI, embeddings are crucial for developing RAG applications. The absence of embedding support renders OpenRouter ineffective in practical application development.