To develop this Golang application, you'll need to follow these steps:

1. Set up your development environment
2. Register a Twitter Developer account and create an App
3. Implement the Twitter API client in Go
4. Perform sentiment analysis using a third-party library or service
5. Store the results in MongoDB
6. Create an HTTP server with an endpoint for querying the stored data

Here's a sample implementation of the required functionality:

```go
package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"

	"github.com/dghubble/go-twitter/twitter"
	"github.com/dghubble/oauth1"
	"github.com/joho/godotenv"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)

type TweetSentiment struct {
	TweetID       int64   `bson:"tweet_id"`
	Text          string  `bson:"text"`
	Sentiment     float64 `bson:"sentiment"`
	Keyword       string  `bson:"keyword"`
}

func main() {
	err := godotenv.Load()
	if err != nil {
		log.Fatal("Error loading .env file")
	}

	consumerKey := os.Getenv("TWITTER_CONSUMER_KEY")
	consumerSecret := os.Getenv("TWITTER_CONSUMER_SECRET")
	accessToken := os.Getenv("TWITTER_ACCESS_TOKEN")
	accessSecret := os.Getenv("TWITTER_ACCESS_SECRET")

	config := oauth1.NewConfig(consumerKey, consumerSecret)
	token := oauth1.NewToken(accessToken, accessSecret)
	httpClient := config.Client(oauth1.NoContext, token)

	client := twitter.NewClient(httpClient)

	keywords := []string{"golang", "mongodb"}

	streamFilterParams := &twitter.StreamFilterParams{
		Track:         keywords,
		StallWarnings: twitter.Bool(true),
	}

	stream, err := client.Streams.Filter(streamFilterParams)
	if err != nil {
		log.Fatal(err)
	}

	demux := twitter.NewSwitchDemux()
	demux.Tweet = func(tweet *twitter.Tweet) {
		sentiment := analyzeSentiment(tweet.Text)
		tweetSentiment := TweetSentiment{
			TweetID:   tweet.ID,
			Text:      tweet.Text,
			Sentiment: sentiment,
			Keyword:   findKeyword(keywords, tweet.Text),
		}
		storeTweetSentiment(tweetSentiment)
	}

	go demux.HandleChan(stream.Messages)

	http.HandleFunc("/query", queryHandler)
	log.Fatal(http.ListenAndServe(":8080", nil))
}

func analyzeSentiment(text string) float64 {
	// Implement your sentiment analysis logic here.
	// You can use a third-party library or service like TextBlob, Google Cloud Natural Language API, etc.
	return 0.0
}

func findKeyword(keywords []string, text string) string {
	for _, keyword := range keywords {
		if strings.Contains(strings.ToLower(text), strings.ToLower(keyword)) {
			return keyword
		}
	}
	return ""
}

func storeTweetSentiment(tweetSentiment TweetSentiment) {
	clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
	client, err := mongo.Connect(context.Background(), clientOptions)
	if err != nil {
		log.Fatal(err)
	}

	collection := client.Database("tweets").Collection("sentiments")

	insertResult, err := collection.InsertOne(context.Background(), tweetSentiment)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println("Inserted tweet with ID:", insertResult.InsertedID)
}

func queryHandler(w http.ResponseWriter, r *http.Request) {
	keyword := r.URL.Query().Get("keyword")
	minSentiment := r.URL.Query().Get("min_sentiment")

	filter := bson.M{"keyword": keyword, "sentiment": bson.M{"$gte": minSentiment}}

	clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
	client, err := mongo.Connect(context.Background(), clientOptions)
	if err != nil {
		log.Fatal(err)
	}

	collection := client.Database("tweets").Collection("sentiments")

	cursor, err := collection.Find(context.Background(), filter)
	if err != nil {
		log.Fatal(err)
	}

	var results []TweetSentiment
	err = cursor.All(context.Background(), &results)
	if err != nil {
		log.Fatal(err)
	}

	json.NewEncoder(w).Encode(results)
}
```

Make sure to replace the placeholder sentiment analysis function `analyzeSentiment` with a real implementation using a third-party library or service.

To run this application, you'll need to create a `.env` file in your project directory containing your Twitter API credentials:

```
TWITTER_CONSUMER_KEY=your_consumer_key
TWITTER_CONSUMER_SECRET=your_consumer_secret
TWITTER_ACCESS_TOKEN=your_access_token
TWITTER_ACCESS_SECRET=your_access_secret
```

You'll also need to install the required dependencies:

```sh
go get github.com/dghubble/go-twitter/twitter
go get github.com/dghubble/oauth1
go get github.com/joho/godotenv
go get go.mongodb.org/mongo-driver/mongo
```

Now you can build and run the application:

```sh
go build -o main
./main
```

The application will start streaming tweets containing the specified keywords, perform sentiment analysis on them, and store the results in MongoDB. You can query the stored data by sending an HTTP request to the `/query` endpoint with the desired keyword and minimum sentiment score as query parameters:

```
http://localhost:8080/query?keyword=golang&min_sentiment=0.5
```
이 Golang 애플리케이션을 개발하려면 다음 단계를 따라야 합니다.

1. 개발 환경 설정
2. 트위터 개발자 계정을 등록하고 앱을 생성합니다
3. Go에서 트위터 API 클라이언트를 구현합니다
4. 타사 라이브러리 또는 서비스를 사용하여 감성 분석을 수행합니다
5. 결과를 몽고DB에 저장합니다
6. 저장된 데이터를 쿼리하기 위한 엔드포인트가 있는 HTTP 서버를 생성합니다

다음은 필요한 기능을 구현한 샘플입니다:

```go
package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"

	"github.com/dghubble/go-twitter/twitter"
	"github.com/dghubble/oauth1"
	"github.com/joho/godotenv"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)

type TweetSentiment struct {
	TweetID       int64   `bson:"tweet_id"`
	Text          string  `bson:"text"`
	Sentiment     float64 `bson:"sentiment"`
	Keyword       string  `bson:"keyword"`
}

func main() {
	err := godotenv.Load()
	if err != nil {
		log.Fatal("Error loading .env file")
	}

	consumerKey := os.Getenv("TWITTER_CONSUMER_KEY")
	consumerSecret := os.Getenv("TWITTER_CONSUMER_SECRET")
	accessToken := os.Getenv("TWITTER_ACCESS_TOKEN")
	accessSecret := os.Getenv("TWITTER_ACCESS_SECRET")

	config := oauth1.NewConfig(consumerKey, consumerSecret)
	token := oauth1.NewToken(accessToken, accessSecret)
	httpClient := config.Client(oauth1.NoContext, token)

	client := twitter.NewClient(httpClient)

	keywords := []string{"golang", "mongodb"}

	streamFilterParams := &twitter.StreamFilterParams{
		Track:         keywords,
		StallWarnings: twitter.Bool(true),
	}

	stream, err := client.Streams.Filter(streamFilterParams)
	if err != nil {
		log.Fatal(err)
	}

	demux := twitter.NewSwitchDemux()
	demux.Tweet = func(tweet *twitter.Tweet) {
		sentiment := analyzeSentiment(tweet.Text)
		tweetSentiment := TweetSentiment{
			TweetID:   tweet.ID,
			Text:      tweet.Text,
			Sentiment: sentiment,
			Keyword:   findKeyword(keywords, tweet.Text),
		}
		storeTweetSentiment(tweetSentiment)
	}

	go demux.HandleChan(stream.Messages)

	http.HandleFunc("/query", queryHandler)
	log.Fatal(http.ListenAndServe(":8080", nil))
}

func analyzeSentiment(text string) float64 {
	// Implement your sentiment analysis logic here.
	// You can use a third-party library or service like TextBlob, Google Cloud Natural Language API, etc.
	return 0.0
}

func findKeyword(keywords []string, text string) string {
	for _, keyword := range keywords {
		if strings.Contains(strings.ToLower(text), strings.ToLower(keyword)) {
			return keyword
		}
	}
	return ""
}

func storeTweetSentiment(tweetSentiment TweetSentiment) {
	clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
	client, err := mongo.Connect(context.Background(), clientOptions)
	if err != nil {
		log.Fatal(err)
	}

	collection := client.Database("tweets").Collection("sentiments")

	insertResult, err := collection.InsertOne(context.Background(), tweetSentiment)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println("Inserted tweet with ID:", insertResult.InsertedID)
}

func queryHandler(w http.ResponseWriter, r *http.Request) {
	keyword := r.URL.Query().Get("keyword")
	minSentiment := r.URL.Query().Get("min_sentiment")

	filter := bson.M{"keyword": keyword, "sentiment": bson.M{"$gte": minSentiment}}

	clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
	client, err := mongo.Connect(context.Background(), clientOptions)
	if err != nil {
		log.Fatal(err)
	}

	collection := client.Database("tweets").Collection("sentiments")

	cursor, err := collection.Find(context.Background(), filter)
	if err != nil {
		log.Fatal(err)
	}

	var results []TweetSentiment
	err = cursor.All(context.Background(), &results)
	if err != nil {
		log.Fatal(err)
	}

	json.NewEncoder(w).Encode(results)
}
```

플레이스홀더 감성 분석 함수 `analyzeSentiment`를 타사 라이브러리 또는 서비스를 사용하여 실제 구현으로 대체해야 합니다.

이 애플리케이션을 실행하려면 프로젝트 디렉토리에 트위터 API 자격 증명이 포함된 `.env` 파일을 만들어야 합니다:

```
TWITTER_CONSUMER_KEY=your_consumer_key
TWITTER_CONSUMER_SECRET=your_consumer_secret
TWITTER_ACCESS_TOKEN=your_access_token
TWITTER_ACCESS_SECRET=your_access_secret
```

또한 필요한 종속성을 설치해야 합니다:

```sh
go get github.com/dghubble/go-twitter/twitter
go get github.com/dghubble/oauth1
go get github.com/joho/godotenv
go get go.mongodb.org/mongo-driver/mongo
```

이제 애플리케이션을 빌드하고 실행할 수 있습니다:

```sh
go build -o main
./main
```

애플리케이션은 지정된 키워드가 포함된 트윗을 스트리밍하기 시작하고, 이에 대한 감성 분석을 수행한 후 그 결과를 MongoDB에 저장합니다. 원하는 키워드와 최소 감성 점수를 쿼리 매개변수로 하여 `/query` 엔드포인트로 HTTP 요청을 보내면 저장된 데이터를 쿼리할 수 있습니다:

```
http://localhost:8080/query?keyword=golang&min_sentiment=0.5
```