But you can configure second factor with keepassxc TOTP
Читать полностью…
I added Text-to-Speech capabilities for the PromptQL v5.3.x! They are also compatible with the OpenAI API. They are implemented with the {~open_query_tts /} and {~listen_query_tts /} commands. And you can check them in these tests:
https://gitlab.com/jbyte777/prompt-ql/-/tree/release-5.x/tests/text-to-speech
Repository of PromptQL v5.3.x is here:
https://gitlab.com/jbyte777/prompt-ql/-/tree/release-5.x
#PromptQL #texttospeech #promptengineering #prompts #messageprotocol #protocol #multiagent
#golang #go #programming #opensource #library #programminglanguage #cottagesoftware #craftprogramming #OpenAI #ml #ai
I replaced PM agent's LLM with local Openhermes model for this tiny software factory:
https://gitlab.com/jbyte777/multiagent-software-minifactory-example/-/tree/openai-openhermes-local-model
And got working tic-tac-toe game with few passes. However, I needed to increase timeout for local LLM. It runs on one machine from 2010s along with the PromptQL factory client.
Here's an implemented game:
https://codepen.io/JZX777/pen/eYxwadx
Here's the Llama.cpp server:
https://github.com/ggerganov/llama.cpp/tree/master/examples/server
#PromptQL #llm #golang #go #programming #opensource #library #programminglanguage #cottagesoftware #craftprogramming #promptengineering #prompts #OpenAI #ml #ai #messageprotocol #protocol
I did some API refactoring for PromptQL library. For making PromptQL library API more focused on prompt templates execution. However, you can still cast the InterpreterApi interface to the *Interpreter type to gain thin control on execution flow. I included the refactoring in the 5.1.0 and 4.2.0 versions.
You can install PromptQL following an instruction from this branch:
https://gitlab.com/jbyte777/prompt-ql/-/tree/release-5.x
#PromptQL #llm #golang #go #programming #opensource #library #programminglanguage #cottagesoftware #craftprogramming #promptengineering #prompts #OpenAI #ml #ai #messageprotocol #protocol
Any OpenAI compatible API can also serve as a custom LLM for PromptQL queries! You can just substitute the default OpenAiBaseUrl with any base url to compatible API. For example, this Llama server implements OpenAI compatible Chat API:
https://github.com/ggerganov/llama.cpp/tree/master/examples/server
And then you can run any PromptQL queries relying on OpenAI models, with just a two-lines config. For example, in this test below which is also shown on screenshots:
https://gitlab.com/jbyte777/prompt-ql/-/blob/release-5.x/tests/dialogues/with-openai-api-compatible-local-llm.go?ref_type=heads
#PromptQL #llm #LocalLLM #Llama #golang #go #programming #opensource #library #programminglanguage #cottagesoftware #craftprogramming #promptengineering #prompts #OpenAI #ml #ai #messageprotocol #protocol
https://gitlab.com/jbyte777/prompt-ql/-/tree/release-4.x
With 3.x and 4.x versions of PromptQL I introduced a mechanism for communicating arbitrary receiving agent at language level. And separated prompt calling from prompt implementation with code embeddings. This way prompts can be incapsulated within agents implementing them.
For more information, you can check these releases:
https://gitlab.com/jbyte777/prompt-ql/-/releases/v3.0.0
https://gitlab.com/jbyte777/prompt-ql/-/releases/v4.0.0
#PromptQL #llm #golang #go #programming #opensource #library #programminglanguage #cottagesoftware #craftprogramming #promptengineering #prompts #OpenAI #ChatGPT #ml #ai #messageprotocol #protocol
Recently I built the PromptQL v2.x major version. This major version reviews the PromptQL language as a messaging protocol for PromptQL agents. These agents can be users, GPT model services etc. For introductory example, you can check this simple two-agent program that uses the PromptQL library:
https://gitlab.com/jbyte777/promptql-v2-hello-world-example
The second major can be installed from this branch:
https://gitlab.com/jbyte777/prompt-ql/-/tree/release-2.x
As the second major reconceptualizes the PromptQL language as a messaging protocol for ML-based agents, it includes these changes:
1. Mismatching command tags are prohibited. For example, executing a {~assistant}<some_text>{/open_query} pair now returns a run-time error;
2. External global variables are separated from internal global variables;
3. The {~hello /} command. For getting variables and models layout of PromptQL agent;
4. Code is executed in "sessions". Session is a flow of code that keeps internal state (internal variables and context stack). "Partial execution" in this case is just a part of current session;
5. Session state management commands: {~session_begin /} and {~session_end /};
For more details on the major, you can visit this page:
https://gitlab.com/jbyte777/prompt-ql/-/releases/v2.0.0
#PromptQL #llm #golang #go #programming #opensource #library #programminglanguage #cottagesoftware #craftprogramming #promptengineering #prompts #OpenAI #ChatGPT #ml #ai #messageprotocol #protocol
https://www.reddit.com/r/conlangs/comments/6sdalz/simple_word_generator_written_in_python/
Wondering that this was even used by some conlang geeks
#retro #nostalgia #python #conlang #linguistics #algorithms #cli
https://gitlab.com/jbyte777/prompt-ql
#llm #programminglanguage #ChatGPT #PromptQL
Интересно. Спасибо за наводку по данным для модели на базе Fourier-Nowruz
Читать полностью…
Try to use setup_key
https://keepassxc.org/docs/KeePassXC_UserGuide#_adding_totp_to_an_entry
Goodbye, GitHub! You was open and nice open-source community. It was a place where beginner developers, programmers etc. could find a lot of projects to start with. It was a place where they also could share their own projects. And this all happened until security policies forced to us. I miss GitHub of 2010s where software engineers could take full freedom and responsibility for their own account and projects.
However, there are still many public repository hosting services which don't require two-factor authentication. Like GitLab. However, there are more of them, just give a try to find them on themselves.
2FA binds an account to more restrictive identities (like "phone number <- ID", devices etc.). If mandatory 2FA continue to grow in public services, then p2p networking will become a more plausible option for engineers. Because in both cases virtual identity is highly restricted, but trust differs.
#thoughts #blog
2200 AD: what was wrong with the big tech dominating empire, such that it collapsed into individual startups, businesses and households in the mid of XXI century?
Читать полностью…
I released the PromptQL v5.2.x . It introduces more control on variables encapsulation. And it also supports reading binary data from file and as HTTP request! Thus you can use it for more flexible configuration of prompts.
For more info, you can check this release:
https://gitlab.com/jbyte777/prompt-ql/-/releases/v5.2.0
To try new features, you can run and modify these examples:
https://gitlab.com/jbyte777/prompt-ql/-/tree/release-5.x/tests/blob-data
https://gitlab.com/jbyte777/prompt-ql/-/blob/release-5.x/tests/control-flow/internal-vars/preinit-internal-vars.go
Repository of PromptQL v5.x is here:
https://gitlab.com/jbyte777/prompt-ql/-/tree/release-5.x
#PromptQL #llm #golang #go #programming #opensource #library #programminglanguage #cottagesoftware #craftprogramming #promptengineering #prompts #OpenAI #ml #ai #messageprotocol #protocol
Reusing external library vs. "Reinventing the wheel"
Most of the time I see Medium articles etc. which extensively advocate usage of external libraries. For solving problems that have more complicated logic than pipelining different APIs etc. I understand this approach: building something from scratch takes up more developing time than using some library to solve the same task. When I build services, I use libraries for routing, database clients, Telegram API etc. Because there exist proven and wrapped solutions for these complicated facilities. And thus I can focus more on implementing high-level features.
But. That's not always a case. There can be niche cases for which existing and suitable library is just harder to find and fit to requirements than to implement. This was the case of PromptQL interpreter, for example. Or SVG map renderer for format generated by some proprietary program.
There can be cases when external library functionality fits initial requirements and some future features close to them. This was the case of Django framework, for example, which fitted basic REST API & SSR facilities very good. Or some huge UI library which fitted design good. However, in long runs they were harder to use with adding new functionality which could not be achieved with their APIs transparently. In case of Django, for example: parsing some data from external API concurrently. Implementing WebSockets notifications. Working with different types of databases at the same time... This resulted in different workarounds which complicated maintaining services further.
So from this experience I tend to choose external libraries carefully. Especially bigger libraries which serve more generic use-cases. If I can't find a reason for why some library with fixed domain X fits a fixed domain X on some project, then I fall for building custom solution instead. Which is easier to modify in details.
(and that's why I love Golang's approach for atomic libraries, for example: one thing is for routing, the other thing is for WebSockets etc.)
Basic math analytical skills, basic algorithms and creative hobbies related to SWE, help to find a good balance between different aspects of SWE for you.
#thoughts #blog #softwareengineering
This is an example of agents net implementing PromptQL v4.x protocol:
https://gitlab.com/jbyte777/multiagent-software-minifactory-example
And here's an implemented game:
https://codepen.io/JZX777/pen/poGaeZz
#PromptQL #llm #golang #go #programming #opensource #library #programminglanguage #cottagesoftware #craftprogramming #promptengineering #prompts #OpenAI #ChatGPT #ml #ai #messageprotocol #protocol
I don't believe in exponential "time acceleration" of human technologies and society changes. I think, agility is a complex coping mechanism for economic/societal instability. When outer space is so scarce to utilize, people start to value time more. Today is not only a time when this happens. But today is different from Dark Ages in more complex technologies, social structures and more discovered space.
It's like when CPU power and RAM were so scarce to handle games that were more complex than Pacman or Arcanoid. Back then, for more sophisticated results, programmers heavily relied on low-level temporal hacks like reusing same variables for different things, scan-line interference (detalization of 8x8 2 color blocks to 8x1 color blocks for ex.) etc. Since 2000s these hacks went obsolete in most cases.
Or it's like when you walk on some overcrowded street. In this case you outperform rest of people only when you walk faster than them on some tight paths.
If rat race is too toxic and non-beneficial for you, then use your time as much as possible to go to lower stress and sustainable place. Be it real (on travel, walking etc,) or imaginary (on building new things with technology etc.).
#thoughts #blog
jzx777/my-journey-to-software-engineering-part-1-pre-career-28e2ad42eec3" rel="nofollow">https://medium.com/@jzx777/my-journey-to-software-engineering-part-1-pre-career-28e2ad42eec3
Читать полностью…
🤔...
"Let me introduce into how atrocity propaganda works. Imagine someone presenting a banana and insisting it's an orange, repeating this assertion so often that those who only saw a banana recall seeing an orange instead.
For instance, they might allege that 'hundreds' of ravers were harmed while only displaying an image of three body bags. Or suggest an entire family tragedy, but only present a stained blanket as evidence. These narratives are echoed relentlessly across media channels, leading audiences to believe they witnessed more than they truly did.
The tactic often pairs distressing visuals with unsettling narratives. When confronted with a shocking image, our defenses drop, making it easier to link that image with the provided story, even if they don't align.
Another method involves enacting laws that criminalize skepticism towards such claims."
PromptQL v1.2.0 release has some additional features for prompting models:
1. Blocking queries. If you just want to make a query and get a result immediately, without verbosity of matching "listen_query" pairs. This is achieved with the "sync" flag of the "open_query" command;
2. "user" flag is now optional for user-defined models. You can just put a name of your own model for a query if this model is not by OpenAI. The "user" flag only assumes that given model is exactly user-defined model.
Examples are here:
https://gitlab.com/jbyte777/prompt-ql/-/blob/master/tests/sync-queries/basic-sync-query.go
https://gitlab.com/jbyte777/prompt-ql/-/blob/master/tests/custom-llms/user-flag-is-optional.go
Repository with detailed info about PromptQL is here:
https://gitlab.com/jbyte777/prompt-ql
#PromptQL #llama #llm #cottagesoftware #craftprogramming #opensource #promptengineering
PromptQL v1.1.0 can be used with your own LLM API. For example, with local Llama
https://gitlab.com/jbyte777/prompt-ql
#llama #llm #promptql
Вот пример задания для бенчмарка, это несложно генерировать с разными уровнями сложности, принцип прост.
Читать полностью…
